第八章 List、Set、数据结构、Collections

  1. 常见的数据结构:

    1. 栈:先进后出,分为压栈和弹栈
    2. 队列:属于线性表的一种,先进先出
    3. 数组:有序元素序列
      1. 查询元素快,通过索引访问指定位置的元素
      2. 增删元素慢,因为增删元素时需要创建一个新的数组,先存元素索引,在存储元素的值
    4. 链表:数据域存储数据,指针域存储下一个结点的地址
      1. 查询元素慢
      2. 增删元素快
  2. List接口常用方法:数组结构特点

    1. 常用语法:

      import java.util.ArrayList;
      import java.util.Iterator;
      import java.util.LinkedList;
      import java.util.List;
      /*
      java.util.List接口 extends Collection接口
      List接口的特点:
      1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)
      2.有索引,包含了一些带索引的方法
      3.允许存储重复的元素

       List接口中带索引的方法(特有)
           - public void add(int index, E element): 将指定的元素,添加到该集合中的指定位置上。
           - public E get(int index):返回集合中指定位置的元素。
           - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
           - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
       注意:
           操作索引的时候,一定要防止索引越界异常
           IndexOutOfBoundsException:索引越界异常,集合会报
           ArrayIndexOutOfBoundsException:数组索引越界异常
           StringIndexOutOfBoundsException:字符串索引越界异常
      

      */
      public class Demo1List {

       public static void main(String[] args) {
      

      // ListMethod1();

           LinkedDemo1();
      
       }
      
       private static void ListMethod1(){
           List<String> list1 = new ArrayList<String>();
           list1.add("123");
           list1.add("测试内容");
           System.out.println("第一次添加测试:"+ list1);
      
           list1.add(1,"添加元素");
           System.out.println("添加的内容:"+list1);
      
           System.out.println("删除索引位置为2的元素:"+list1.remove(2));
      
           list1.set(0,"修改元素");
           System.out.println("指定位置修改元素:"+list1);
      
           // 遍历列表集合
           for (int i = 0; i <list1.size() ; i++) {
               System.out.println("遍历的结果:"+list1.get(i));
      
           }
      
       }
      
  3. LinkedList:

    1. 集合数据存储的结构是链表结构。方便元素添加、删除的集合

      /*
          java.util.LinkedList集合 implements List接口
          LinkedList集合的特点:
              1.底层是一个链表结构:查询慢,增删快
              2.里边包含了大量操作首尾元素的方法
              注意:使用LinkedList集合特有的方法,不能使用多态
      
              - public void addFirst(E e):将指定元素插入此列表的开头。
              - public void addLast(E e):将指定元素添加到此列表的结尾。
              - public void push(E e):将元素推入此列表所表示的堆栈。
      
              - public E getFirst():返回此列表的第一个元素。
              - public E getLast():返回此列表的最后一个元素。
      
              - public E removeFirst():移除并返回此列表的第一个元素。
              - public E removeLast():移除并返回此列表的最后一个元素。
              - public E pop():从此列表所表示的堆栈处弹出一个元素。
      
              - public boolean isEmpty():如果列表不包含元素,则返回true。
      
       */
      public class LinkedListDemo {
      public static void main(String[] args) {
          LinkedList<String> link = new LinkedList<String>();
              //添加元素
              link.addFirst("abc1");
              link.addFirst("abc2");
              link.addFirst("abc3");
              System.out.println(link);
              // 获取元素
              System.out.println(link.getFirst());
              System.out.println(link.getLast());
              // 删除元素
              System.out.println(link.removeFirst());
              System.out.println(link.removeLast());
              while (!link.isEmpty()) { //判断集合是否为空
              System.out.println(link.pop()); //弹出集合中的栈顶元素
              }
              System.out.println(link);
          }
      }
      
      1. Set集合

        1. 存储的数据是不可重复且无需的;

        2. 底层实现是hashMap;

        3. 保证元素唯一性方法依赖于hashCode and equals方法;

        4. 给HashSet中存放自定义元素是,需要重写hashCode 和equals方法;

          import java.security.PublicKey;
          import java.util.HashSet;
          import java.util.LinkedHashSet;

          /*
          java.util.Set接口 extends Collection接口
          Set接口的特点:
          1.不允许存储重复的元素
          2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
          java.util.HashSet集合 implements Set接口
          HashSet特点:
          1.不允许存储重复的元素
          2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
          3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
          4.底层是一个哈希表结构(查询的速度非常的快)
          */
          public class Demo1Set {
          public static void main(String[] args) {
          HashSetDemo();
          LinkedHashSetTest();

           }
          
           private static void HashSetDemo(){
               HashSet<String> settest1 = new HashSet<String>();
          
               settest1.add("abc");
               settest1.add("abc");
               settest1.add("123");
               settest1.add("456");
               System.out.println(settest1);  // 无序不重复
               for (String s : settest1) {
                   System.out.println(s);
               }
          
           }
          
           private static void LinkedHashSetTest(){
               LinkedHashSet<String> linked = new LinkedHashSet<String>();
               linked.add("123");
               linked.add("123");
               linked.add("789");
               linked.add("456");
               System.out.println("LinkedHashSetTest内容测试:"+linked); // 有序不重复
               for (String i:linked){
                   System.out.println("遍历后的结果:"+ i);
               }
          
           }
          

          }

        HashSet:

        存储自定义类型元素:哈希表底层采用数组+链表实现

        LinkedHashSet:

        链表和哈希表组合的一个数据存储结构

        1. 可变参数:

          1. 参数类型一致,且需要接受多个参数

          2. 底层实现是一个数组

            /*
                1.可变参数:是JDK1.5之后出现的新特性
                使用前提:
                    当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数.
                使用格式:定义方法时使用
                    修饰符 返回值类型 方法名(数据类型...变量名){}
                可变参数的原理:
                    可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数
                    传递的参数个数,可以是0个(不传递),1,2...多个
            
                2. 可变参数的注意事项
                    1.一个方法的参数列表,只能有一个可变参数
                    2.如果方法的参数有多个,那么可变参数必须写在参数列表的末尾
             */
            
                /*public static void method(String b,double c,int d,int...a){
                }*/
            
            public class Demo1ChangeArgs {
                public static void main(String[] args) {
            
            //        int a = addTest(1,3,4,5,6);
            //        int b = sumTest(10,20,30,40,50);
            //        System.out.println("可变参数sum结果:"+ b);
                    method("abc",5.5,10,1,2,3,4);
                }
            
                public static int addTest(int...arrTest){
                    System.out.println(arrTest);  // 地址值
                    System.out.println(arrTest.length);  // 长度
                    return 0;
            
                }
            
                public static int sumTest(int...arrTest){
                    int sum = 0;
                    for (int i : arrTest) {
                        sum+=i;
            
                    }
                    return sum;
                }
            
                public static void method(Object...obj){
                    System.out.println(obj);
            
                }
            }
            
        2. Collections

          import java.util.ArrayList;
          import java.util.Collection;
          import java.util.Collections;
          import java.util.Comparator;
          /*public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。
          public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
          public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
          public static <T> void sort(List<T> list,Comparator<? super T> ) :将集合中元素按照指定规则排*/
          public class CollectionDemo {
              public static void main(String[] args) {
          
                  Demo1();
                  comparetorDemo1();
          
              }
          
              public static void Demo1(){
                  ArrayList<Integer> list1 = new ArrayList<Integer>();
                  Collections.addAll(list1, 1,2,4,8,5);
                  System.out.println("集合工具类之添加元素:"+list1);
          
                  Collections.sort(list1);
                  System.out.println("排序后的结果:"+ list1);
              }
          
              public static void comparetorDemo1(){
          
                  ArrayList<String> list1 = new ArrayList<String>();
                  Collections.addAll(list1, "abc", "cba", "bac");
          
                  Collections.sort(list1, new Comparator<String>() {
                      @Override
                      public int compare(String o1, String o2) {
          //                return o2.charAt(0) - o1.charAt(0); // 降序操作
                          return o1.charAt(0) - o2.charAt(0);  // 升序操作
          
                      }
                  });
                  System.out.println("升序操作:"+ list1);
          
              }
          }
          
        3. Comparator比较器

相关推荐
汇匠源12 分钟前
零工市场小程序如何提高找兼职的效率?
java·大数据·开发语言·小程序·团队开发
一 乐17 分钟前
订餐点餐|订餐系统基于java的订餐点餐系统小程序设计与实现(源码+数据库+文档)
java·数据库·spring boot·后端·源码
dulu~dulu30 分钟前
数据冒险与控制冒险
java·开发语言·计算机组成原理
VX_CXsjNo133 分钟前
免费送源码:Java+B/S+ssm+MySQL 公众养老服务网上预订系统 计算机毕业设计原创定制
java·爬虫·mysql·eclipse·前端框架·课程设计·myeclipse
今天多喝热水2 小时前
Java工具--stream流
java
罗曼蒂克在消亡2 小时前
JDK——java.util.function
java·jdk
J不A秃V头A2 小时前
JSON字符串转换成Java集合对象
java·json
john_hjy3 小时前
7. 机器人项目
java·前端·javascript
那你为何对我三笑留情3 小时前
一、Spring Boot集成Spring Security之自动装配
java·spring boot·spring·spring security
鱼跃鹰飞3 小时前
大厂面试真题-介绍以下Docker的Overlay网络
java·网络·docker·容器·面试·职场和发展