集合总结

最新推荐文章于 2022-03-03 20:28:46 发布

我是廿六啊

最新推荐文章于 2022-03-03 20:28:46 发布

阅读量122

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/weixin_43529244/article/details/106339075

版权

笔记专栏收录该内容

25 篇文章 0 订阅

订阅专栏

集合的特点：
      Set系列集合：添加的元素是无序，不重复，无索引的。
            -- HashSet:添加的元素是无序，不重复，无索引的。
            -- LinkedHashSet:添加的元素是有序，不重复，无索引的。
            -- TreeSet:不重复，无索引，按照大小默认升序排序!!
      List系列集合：添加的元素是有序，可重复，有索引。
            -- ArrayList：添加的元素是有序，可重复，有索引。
            -- LinekdList：添加的元素是有序，可重复，有索引。

/**
    目标：Collection集合的遍历方式。

    什么是遍历? 为什么开发中要遍历？
        遍历就是一个一个的把容器中的元素访问一遍。
        开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。

    Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它。
    Collection集合的遍历方式有三种:
        （1）迭代器。
        （2）foreach(增强for循环)。
        （3）JDK 1.8开始之后的新技术Lambda表达式(了解)

    a.迭代器遍历集合。
        -- 方法：
            public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的
            E next():获取下一个元素值！
            boolean hasNext():判断是否有下一个元素，有返回true ,反之。
        --流程：
            1.先获取当前集合的迭代器
                Iterator<String> it = lists.iterator();
            2.定义一个while循环，问一次取一次。
              通过it.hasNext()询问是否有下一个元素，有就通过
              it.next()取出下一个元素。
        小结：
            记住！
 */
public class CollectionDemo01 {
    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("殷素素");
        lists.add("周芷若");
        System.out.println(lists);
        // lists = [赵敏, 小昭, 殷素素, 周芷若]
        //   it

        // 1.得到集合的迭代器对象。
        Iterator<String> it = lists.iterator();
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next()); // 出现异常NoSuchElementException，出现没有此元素异常！

        // 2.使用while循环遍历。
        while(it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
        }

    }
}

collection的遍历方式

1.迭代器

创建集合 —— Collection lists = new ArrayList<>();
得到集合的迭代器对象 —— Iterator it = lists.iterator();集合是什么泛型迭代器就是什么类型
while循环遍历——(不知道循环的次数使用while循环)

while（it.hasNext()）{

System.out.println(it.next());

}

2.foreach

 foreach是一种遍历形式，可以遍历集合或者数组。
 foreach遍历集合实际上是迭代器遍历的简化写法。
 foreach遍历的关键是记住格式：
    for(被遍历集合或者数组中元素的类型 变量名称 : 被遍历集合或者数组){
    }

创建集合 —— Collection lists = new ArrayList<>();
格式：for（被遍历集合或数组的类型变量名称：被遍历集合或数组）{

System.out.println(变量名称);

}

3.Lambda表达式

创建集合 —— Collection lists = new ArrayList<>();
格式：集合名.forEach(变量名->{

System.out.println(变量名);

})

数据结构

数组：查询快，增删慢
链表：查询慢，增删快
红黑树：增删改查的性能都好
队列:先进先出，后进后出
栈：先进后出，后进先出

List集合

有序，可重复，有索引

ArrayList集合

List<String> lists = new ArrayList<>();
lists.add("java1");
lists.add("java1");
lists.add("java2");
lists.add("java2");
System.out.println(lists);

// 2.在某个索引位置插入元素。
lists.add(2,"MySQL");
System.out.println(lists);

// 3.根据索引删除元素,返回被删除元素
System.out.println(lists.remove(2));
System.out.println(lists);

// 4.根据索引获取元素
System.out.println(lists.get(2)); // java2

// 5.修改索引位置处的元素
lists.set(3,"Mybatis");
System.out.println(lists);

List系列的遍历方式有4种

for循环
foreach
迭代器
Lambda表达式

LinkedList

底层是基于链表的，增删快，查询慢

LinkedList是双链表，定为前后元素是非常快的，增删首尾的元素也是非常快的。（操作首尾元素的特殊功能）

查询多的用ArrayList,增删多的用LinkedList

         -public void addFirst(E e):将指定元素插入此列表的开头。
         - public void addLast(E e):将指定元素添加到此列表的结尾。
         - public E getFirst():返回此列表的第一个元素。
         - public E getLast():返回此列表的最后一个元素。
         - public E removeFirst():移除并返回此列表的第一个元素。
         - public E removeLast():移除并返回此列表的最后一个元素。
         - public E pop():从此列表所表示的堆栈处弹出一个元素。
         - public void push(E e):将元素推入此列表所表示的堆栈。
    public static void main(String[] args) {
    // 1.用LinkedList做一个队列:先进先出，后进后出。
    LinkedList<String> queue = new LinkedList<>();
    // 入队
    queue.addLast("1号");
    queue.addLast("2号");
    queue.addLast("3号");
    queue.addLast("4号");
    System.out.println(queue); // [1号, 2号, 3号, 4号]
    // 出队
    System.out.println(queue.removeFirst());
    System.out.println(queue.removeFirst());
    System.out.println(queue);

    // 做一个栈
    LinkedList<String> stack = new LinkedList<>();
    // 压栈
    stack.push("第1颗子弹");
    stack.push("第2颗子弹");
    stack.push("第3颗子弹");
    stack.push("第4颗子弹");
    System.out.println(stack); // [第4颗子弹, 第3颗子弹, 第2颗子弹, 第1颗子弹]
    // 弹栈
    System.out.println(stack.pop());
    System.out.println(stack.pop());
    System.out.println(stack);


}

Set系列集合

遍历方式只有三种

迭代器
foreach
Lambda表达式

无序，不重复，无索引

HashSet：无序，不重复，无索引

LinkedHashSet：有序不重复无索引

TreeSet:不重复无索引

经典代码——Set sets = new HashSet<>();

如果希望Set集合认为两个对象只要内容一样就重复了，就必须重写对象的hashCode和equals方法

哈希值 hashCode()

总结:

如果希望元素可以重复，有索引，查询快用ArrayList
如果希望元素可以重复，有索引，增删快，用LinkedList(适合查询元素较小的情况，经常要首尾操作的元素)
增删改查都很快，但是元素不重复无序无索引就用HashSet
增删改查很快还有序，但是元素不重复无索引，那么用LinkedHashSet集合

TreeSet集合（可以自定义比较规则来进行集合排序）

不重复无索引按照大小默认升序排列

1.有值特性的元素直接可以升序排序。（浮点型，整型）
2.字符串类型的元素会按照首字符的编号排序。
3.对于自定义的引用数据类型，TreeSet默认无法排序，执行的时候直接报错，因为人家不知道排序规则。

字符串类型的元素会按照字符的首字母的排序

对引用数据类型自定义比较器规则接口Comparable,重写比较方法
直接为集合设置比较器对象，重写比较方法

自定义比较器规则
```
public class People implements Comparable<People> {
```

为集合设置比较器规则

Set<People> list = new TreeSet<>(new Comparator<People>() {
    @Override
    public int compare(People o1, People o2) {
        return o1.getAge()-o2.getAge();
    }

注意:如果类和集合都带有比较规则，优先使用集合自带的比较规则。

Collections工具类

常用API

Collections.addAll(集合名称，添加的元素)；

注意：添加的元素的类型要和集合元素的类型一致
Collections.shuffle(集合名称)；——打乱集合顺序（只能打乱List集合）
只能对List集合进行排序

Collectins.sort(集合名称)；//默认升序排序
```
Collections.sort(oranges1, new Comparator<Orange>() {
    @Override
    public int compare(Orange o1, Orange o2) {
        return o1.getWeight-o2.getWeight;
    }
});
```
注意：引用类型比较要进行比较规则自定义，定义方式与TreeSet比较方式一致。此位置在sort排序位置自定义比较规则而不是在集合里定义。

可变参数

    可变参数用在形参中可以接收多个数据。
    可变参数的格式：数据类型... 参数名称

    可变参数的作用：
         传输参数非常灵活，方便。
         可以不传输参数。
         可以传输一个参数。
         可以传输多个参数。
         可以传输一个数组。

    可变参数在方法内部本质上就是一个数组。
    可变参数的注意事项：
            1.一个形参列表中可变参数只能有一个！！
            2.可变参数必须放在形参列表的最后面！！
    小结：
         可变参数的作用：传输参数非常灵活，方便。
         可变参数的注意事项：
         1.一个形参列表中可变参数只能有一个！！
         2.可变参数必须放在形参列表的最后面！！

 */
public class MethodDemo {
    public static void main(String[] args) {
        sum(); // 可以不传输参数。
        sum(10); // 可以传输一个参数。
        sum(10,20,30); // 可以传输多个参数。
        sum(new int[]{10,30,50,70,90}); // 可以传输一个数组。
    }

    public static void sum(int...nums){
        // 可变参数在方法内部本质上就是一个数组。
        System.out.println("元素个数："+nums.length);
        System.out.println("元素内容："+ Arrays.toString(nums));
        System.out.println("--------------------------");
    }
}