day06-集合-Collection&List&Set

于 2024-09-03 09:12:17 发布
阅读量510 收藏 7
点赞数 22
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58478983/article/details/141844354
版权

一、集合

Collection集合特点：

  • list系列集合：有序、可重复

    • ArrayList、LinekdList

  • Set系列集合：无序、不重复

    • HashSet

    • LinkedHashSet:存取有序

    • TreeSet:可排序

1.1 Collection的常见方法

Collection<E> 这是单列集合的根接口
 boolean add(E e) 添加元素
 boolean remove(E e) 删除指定的元素 (如有重复删除第一个)
 boolean contains(Object obj) 判断集合中是否包含指定元素
 int size() 返回集合中元素的个数
 boolean isEmpty() 判断集合是否为空
 Object[] toArray() 将集合中元素存入一个对象数组并返回
 T[] toArray(T[]a)  将集合中元素存入一个指定类型的数组并返回(指定数组长度)
 void clear() 清空集合
 void addAll(集合) 添加另外一个集合中的元素
public class Demo2 {
    public static void main(String[] args) {
        //多态创建单列集合
        Collection<String> coll = new ArrayList<>();
        //boolean add(E e) 添加元素
        coll.add("下雨");
        coll.add("下雪");
        coll.add("刮风");
        coll.add("刮风");
        System.out.println(coll);
​
        //boolean remove(E e) 删除指定的元素 (如有重复删除第一个)
        coll.remove("刮风");
        System.out.println(coll);
​
        //boolean contains(Object obj) 判断集合中是否包含指定元素
        boolean contains = coll.contains("下雪");
        System.out.println("contains=" + contains);
​
        //int size() 返回集合中元素的个数
        int size = coll.size();
        System.out.println("size=" + size);
​
        //boolean isEmpty() 判断集合是否为空
        boolean empty = coll.isEmpty();
        System.out.println("empty=" + empty);//空-->true；否则-->false
​
        //Object[] toArray() 将集合中元素存入一个对象数组并返回
        Object[] objects = coll.toArray();
        System.out.println(Arrays.toString(objects));
​
        //T[] toArray(T[]a)  将集合中元素存入一个指定类型的数组并返回(指定数组长度)
        String[] strings = coll.toArray(new String[coll.size()]);
        System.out.println(Arrays.toString(strings));
​
        //void clear() 清空集合
        coll.clear();
        System.out.println(coll);
​
    }
}
运行结果：
[下雨, 下雪, 刮风, 刮风]
[下雨, 下雪, 刮风]
contains=true
size=3
empty=false
[下雨, 下雪, 刮风]
[下雨, 下雪, 刮风]
[]

1.2 Collection的遍历方式

1.2.1 迭代器Iterator

遍历1: 迭代器Iterator（不回头，用完需要重现创建）
 单列集合专用遍历方式
​
Iterator相关方法
 Iterator<E> iterator() 获取迭代器对象，默认指向第一个元素
 boolean hasNext() 断当前位置是否有元素可以取出 (有返回true，没有返回false)
 E next() 返回当前位置的元素，并将送代器后移一位(如果没有元素可以取出了还继续取，会报NoSuchElementException)
​
固定格式
 Iterator<String> iterator  = list.iterator();
 while (iterator.hasNext()) {
     String s = iterator.next();
 }
public class Demo3 {
    public static void main(String[] args) {
        //1. 准备一个集合
        Collection<String> collection = new ArrayList<>();
        collection.add("java");
        collection.add("python");
        collection.add("c++");
        collection.add("c#");
​
        //2. 获取迭代器对象
        Iterator<String> iterator = collection.iterator();
        //3. 使用迭代器遍历
        while(iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
    }
}

1.2.2 增强for

遍历2: 增强for循环
 数组和集合都可以使用
​
相关格式
 for(元素数据类型 变量名 : 数组或者集合){
     操作变量
 }
​
注意
    1. 在增强for循环中修改数据, 是不会影响数据源的(底层会创建临时变量,来记录容器中的数据)
    2. 增强for遍历集合,底层是迭代器遍历集合的逻辑
    3. 增强for遍历数组,底层是普通for循环的逻辑
public class Demo4 {
    public static void main(String[] args) {
        //1. 准备一个集合
        Collection<String> collection = new ArrayList<>();
        collection.add("java");
        collection.add("python");
        collection.add("c++");
        collection.add("c#");
​
        //2. 使用增强for循环遍历
        for (String s : collection) {
            System.out.println(s);
        }
​
​
​
        //增强for循环也可以遍历数组
        int[] arr = {1,2,3};
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

1.2.3 Lambda表达式方式

遍历3: Lambda表达式方式遍历集合
​
相关格式
 collection.forEach(e -> {
     System.out.println(e);
 });
public class Demo5 {
    public static void main(String[] args) {
        //1. 准备一个集合
        Collection<String> collection = new ArrayList<>();
        collection.add("java");
        collection.add("python");
        collection.add("c++");
        collection.add("c#");
​
        //2. Lambda表达式方式遍历集合
        collection.forEach((e)->{
            //遍历集合中的元素e
            System.out.println(e);
        });
​
    }
}

1.3 删除集合元素

问题
 使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。
 
 由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强for循环遍历集合，又在同时删除集合中的数据时，程序也会出现并发修改异常的错误
​
解决方法
 迭代器: 用迭代器自己的删除方法删除数据即可(iterator.remove();)
 增强for循环: 暂时无法解决
 普通for循环(需要有索引)：可以倒着遍历并删除；或者从前往后遍历，但删除元素后做（i--）操作。
public class Demo7 {
    public static void main(String[] args) {
        //1. 准备一个集合
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Java入门");
        arrayList.add("宁夏枸杞");
        arrayList.add("黑枸杞");
        arrayList.add("人字拖");
        arrayList.add("特级枸杞");
        arrayList.add("枸杞子");
​
        //使用迭代器方式，删除所有带枸杞的
        Iterator<String> iterator = arrayList.iterator();
        while(iterator.hasNext()){
            //获取元素
            String str = iterator.next();
            if(str.contains("枸杞")){
                //通过迭代器删除
                iterator.remove();//从迭代器中删除当前元素
            }
        }
        System.out.println(arrayList);//[Java入门, 人字拖]
    }
}

1.4 集合存储对象的原理

二、List集合

2.1 List集合常用方法

List系列集合的特点
    有序的, 可重复
​
List集合支持索引，所以提供了很多通过索引操作元素的方法
    void add(int index,E e) 在此集合中的指定位置插入指定的元素
    E remove(int index) 删除指定索引处的元素，返回被删除的元素 (一般不接收)
    E set(int index,E e) 修改指定索引处的元素，返回被修改的元素(一般不接收)
    E get(int index) 返回指定索引处的元素
public class Demo1 {
    public static void main(String[] args) {
        //多态方式创建list集合
        List<String> list = new ArrayList<>();
        list.add("张三");//0
        list.add("李四");//1
        list.add("王五");//2
        list.add("郭七");//3
        System.out.println(list);
        //void add(int index,E e) 在此集合中的指定位置插入指定的元素
        list.add(2, "赵六");
        System.out.println(list);
​
        //E remove(int index) 删除指定索引处的元素，返回被删除的元素 (一般不接收)
        list.remove(3);
        System.out.println(list);
        //E set(int index,E e) 修改指定索引处的元素，返回被修改的元素(一般不接收)
        list.set(1,"钱八");
        System.out.println(list);
        //E get(int index) 返回指定索引处的元素
        list.get(1);
        System.out.println(list.get(1));
​
        System.out.println(list);
    }
}

2.2 list集合遍历

List支持的遍历方式
    1. 迭代器
    2. 增强for循环
    3. Lambda表达式
    4. for循环（因为List集合有索引）
public class Demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("王五");
​
        //1. 迭代器
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
        System.out.println("===========================");
​
        //2. 增强for循环
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("===========================");
​
        //3. Lambda表达式
        list.forEach(e ->{
            System.out.println(e);
        });
        System.out.println("===========================");
​
        //4. for循环（因为List集合有索引）
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
​
​
    }
}

2.3 ArrayList

2.3.1 ArrayList底层原理

ArrayList
 底层数据结构:
     基于数组实现
 特点:（查询快，增删慢）
        1. 查询速度快(通过索引直接定位)
        2. 增删效率低(增删的时候,需要移动增删元素后面的元素, 有时还需要进行扩容)
 适用场景:
        1. ArrayList适合于根据索引查询数据, 或者数据量不大的场景
        2. ArrayList不适合于数据量大, 同时又要频繁进行增删操作的场景
 底层原理:
       1. 利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组
         ArrayList<String> list = new ArrayList();
       2. 添加第一个元素时,底层会创建一个新的长度为10的数组
         list.add("a");
       3. 存满时,会扩容1.5倍
         比如存入第11个元素的时候, 长度会扩容到15
       4. 如果一次添加多个元素, 1.5倍还放不下, 则新创建数组的长度以实际为准
         比如原来是10个元素,现在又要存入10个, 则长度会扩容到20

2.3.2 LinkedList集合的底层原理

LinkedList
 底层数据结构:
     基于双向链表实现(内存地址不连续,每个元素记录自己的前后元素)
 特点:
        1. 查询速度慢
        2. 增删效率高
        3. 对于首尾元素进行增删改查的速度都是极快的
 应用场景:
        1. 用来设计队列(两端开口,类似于一个管道,先进先出)
         只操作首尾元素, 尾部添加, 首部删除
        2. 用来设计栈(一段开口,类似于弹夹,先进后出)

 

public class Demo4 {
​
    public static void main(String[] args) {
        makeQueue();
        System.out.println("----------------");
        makeStack();
    }
​
    /*
        队列: 两端开口，特点是先进先出(排队)
        从队列后端入队列:  addLast 方法
        从队列前端出队列:  removeFirst方法
    */
    public static void makeQueue() {
​
        LinkedList<String> queue = new LinkedList<>();
​
        //从队列后端入队列: addLast方法
        queue.addLast("第1位顾客");
        queue.addLast("第2位顾客");
        queue.addLast("第3位顾客");
        queue.addLast("第4位顾客");
        System.out.println(queue);
​
        //从队列前端出队列: removeFirst方法
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
    }
运行结果：
    [第1位顾客, 第2位顾客, 第3位顾客, 第4位顾客]
    第1位顾客
    第2位顾客
    [第3位顾客, 第4位顾客]
​
    /*
        栈: 顶端开口的结构，特点是先进后出
        进栈/压栈: push方法(底层封装了addFirst 方法)
        出栈/弹栈: pop方法底 (底层封装了removeFirst方法)
    */
    public static void makeStack() {
        LinkedList<String> stack = new LinkedList<>();
​
        //进栈/压栈: push方法(底层封装了addFirst 方法)
        stack.push("第1颗子弹");
        stack.push("第2颗子弹");
        stack.push("第3颗子弹");
        stack.push("第4颗子弹");
        System.out.println(stack);
​
        //出栈/弹栈: pop方法底(底层封装了removeFirst方法)
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack);
    }
 运行结果：
    [第4颗子弹, 第3颗子弹, 第2颗子弹, 第1颗子弹]
    第4颗子弹
    第3颗子弹
    [第2颗子弹, 第1颗子弹]   
}

三、Set系列集合

1、Set系列集合的特点是啥？

无序、不重复

2、Set集合的常见实现类有哪几个？各自有啥特点?

HashSet ：无序、不重复

LinkedHashSet： 有序、不重复

TreeSet ：可排序、不重复

public class Demo1 {
    public static void main(String[] args) {
        testHashSet();
        System.out.println("==========");
        testLinkedHashSet();
        System.out.println("==========");
        testTreeSet();
    }
​
    //HashSet: 无序、没有索引、不可重复
    private static void testHashSet() {
        HashSet<Integer> hashSet = new HashSet<>();
        hashSet.add(44);
        hashSet.add(33);
        hashSet.add(11);
        hashSet.add(22);
        hashSet.add(22);
        System.out.println(hashSet);
    }
​
    //LinkedHashSet: 存取有序、没有索引、不可重复
    private static void testLinkedHashSet() {
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add(44);
        linkedHashSet.add(33);
        linkedHashSet.add(11);
        linkedHashSet.add(22);
        linkedHashSet.add(22);
        System.out.println(linkedHashSet);
    }
​
    //TressSet: 排序、无序、没有索引、不可重复
    private static void testTreeSet() {
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(44);
        treeSet.add(33);
        treeSet.add(11);
        treeSet.add(22);
        treeSet.add(22);
        System.out.println(treeSet);
    }
}
​

 

3.1 HashSet

3.1.1 哈希值

哈希值
    就是一int值，Java每个对象都可以通过hashCode方法，获取自己的哈希值
    
    public int hashCode()：返回对象的哈希码值。 
​
​
哈希值特点
    1.同一个对象多次调用hashCode方法，返回的哈希值是相同的;
    2.不同的对象，他们哈希值大几率不相同，但是也有可能会相同(哈希碰撞)
    3.Object的hashCode方法根据"对象地址值"计算哈希值，子类重写后的hashCode方法可以根据"对象属性值"计算哈希值
​
使用场景
    HashSet集合判定两个对象的标准就是两个对象的hash值是否一致, 因此我们经常重写hashcode实现集合中对象去重
public class Demo2 {
    public static void main(String[] args) {
        //创建一个学生对象，获取对象的哈希值
        //1.同一个对象多次调用hashCode方法，返回的哈希值是相同的;
        Student student = new Student("Tom", 15);
        int code = student.hashCode();
        System.out.println(code);
        int code1 = student.hashCode();
        System.out.println(code1);
​
        //2.不同的对象，他们哈希值大几率不相同，但是也有可能会相同(哈希碰撞)
        Student student1 = new Student("Jerry", 16);
        int code2 = student1.hashCode();
        System.out.println(code2);
        //3.Object的hashCode方法根据"对象地址值"计算哈希值
        //子类重写后的hashCode方法可以根据"对象属性值"计算哈希值
        Student student2 = new Student("Jerry", 16);
        int code3 = student2.hashCode();
        System.out.println(code3);
    }
}
​
class Student{
    private String name;
    private int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    //重写hashCode方法，根据对象的属性值计算哈希值
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

 

3.1.2 Set集合去重

需求：

创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合，要求：学生对象的成员变量值相同，我们就认为是同一个对象

分析

①定义学生类，创建HashSet集合对象, 创建学生对象

②把学生添加到集合

③在学生类中重写两个方法，hashCode()和equals()，自动生成即可

public class Demo2 {
    public static void main(String[] args) {
    
        //通过HashSet集合，存储学生数据（去重：需要重写hashCode()和equals()）
        HashSet<Student> students = new HashSet<>();
        //构造几个学生对象，存入set集合
        Student student1 = new Student("Tom", 15);
        Student student2 = new Student("Tom", 15);
        Student student3 = new Student("Tim", 19);
        students.add(student1);
        students.add(student2);
        students.add(student3);
        System.out.println(students);
    }
}
​
class Student{
    private String name;
    private int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    //重写hashCode方法，根据对象的属性值计算哈希值
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

 

3.1.3 HashSet集合的底层原理

  • 基于哈希表实现

  • 哈希表是一种增删改查数据，性能都较好的数据结构。

1、HashSet集合的底层原理是什么样的?

基于哈希表实现的。

JDK8之前的，哈希表：底层使用数组+链表组成

JDK8开始后，哈希表：底层采用数组+链表+红黑树组成。

2、HashSet集合利用哈希表操作数据的详细流程是咋回事？

① 创建一个默认长度16，默认加载因为0.75的数组，数组名table

② 根据元素的哈希值跟数组的长度计算出应存入的位置

③ 判断当前位置是否为null，如果是null直接存入，如果位置不为null，表示有元素，

则调用equals方法比较属性值，如果一样，则不存，如果不一样，则存入数组.

④ 当数组存满到16*0.75=12时，就自动扩容，每次扩容原先的1倍

 

 

3.2 LinkedHashSet

3.3 TreeSet

TreeSet 可排序（默认升序排序 ，按照元素的大小，由小到大排序）、不重复、无索引
 底层基于红黑树实现排序，排序规则认为属性是相同的对象则不存
​
TreeSet的排序
 对于数值型Integer、Double，默认按照数值升序排列;
 对于String类型数据，默认按照字典排序
 
 对于自定义类，默认是无法排序的，需要我们指定排序规则
     1.自然排序:自定义类实现Comparable接口，重写compareTo方法，指定排序规则
     2.比较器排序:写在TreeSet构造参数中传递Comparator比较器对象，重写compare方法，指定排序规则
​
​

需求 使用TreeSet存储教师对象，重复对象不存，并且用两种方式按照年龄升序排列

//比较器排序:写在TreeSet构造参数中传递Comparator比较器对象，重写compare方法，指定排序规则
public class Demo4 {
​
    public static void main(String[] args) {
        //创建TreeSet
        TreeSet<Teacher> treeSet = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                return o1.getAge()-o2.getAge();
            }
        });
​
        //添加学生
        treeSet.add(new Teacher("张三", 19));
        treeSet.add(new Teacher("李四", 18));
        treeSet.add(new Teacher("王五", 20));
        treeSet.add(new Teacher("赵六", 17));
        treeSet.add(new Teacher("赵六", 17));
​
        //打印
        for (Teacher teacher : treeSet) {
            System.out.println(teacher);
        }
    }
}
​
class Teacher {
    private String name;
    private int age;
​
    public Teacher() {
    }
​
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
}
运行结果：
    Teacher{name='赵六', age=17}
    Teacher{name='李四', age=18}
    Teacher{name='张三', age=19}
    Teacher{name='王五', age=20}
//自然排序:自定义类实现Comparable接口，重写compareTo方法，指定排序规则
public class Demo5 {
    public static void main(String[] args) {
        //创建TreeSet
        TreeSet<Teacher1> treeSet = new TreeSet<>();

        //添加学生
        treeSet.add(new Teacher1("张三", 19));
        treeSet.add(new Teacher1("李四", 18));
        treeSet.add(new Teacher1("王五", 20));
        treeSet.add(new Teacher1("赵六", 17));
        treeSet.add(new Teacher1("赵六", 17));

        //打印
        for (Teacher1 teacher : treeSet) {
            System.out.println(teacher);
        }
    }
}

class Teacher1 implements Comparable<Teacher1>{
    private String name;
    private int age;

    public Teacher1() {
    }

    public Teacher1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Teacher1 o) {
        return this.age - o.age;
    }
}
运行结果：
	Teacher{name='赵六', age=17}
	Teacher{name='李四', age=18}
	Teacher{name='张三', age=19}
	Teacher{name='王五', age=20}

四、总结

草莓屁屁不酸
关注
  • 22
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day03-常用API&异常&Collection;.pdf
08-23
- Collection接口的两个重要的子接口是List和Set。 - **List**：有序集合，允许存储重复元素，可以通过索引来访问元素。常用实现类有ArrayList和LinkedList。 - **Set**：不允许存储重复元素，常见实现类有...
day06-集合1
08-04
`Set`接口继承自`Collection`接口，它不保证集合中元素的顺序，不允许有重复元素。在Java中，常见的`Set`实现类有`HashSet`、`TreeSet`等。`Set`集合的特性包括： - 存储元素无序：`Set`集合中元素的插入顺序可能...
2021-08-01 复习 java进阶 day05-集合Collection&List
小虫虫的博客
08-01 490
复习 java进阶 day05-集合Collection&List @1.Collection集合 1.1集合体系结构【记忆】 集合类的特点 提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变 集合类的体系图 1.2Collection集合概述和基本使用【应用】 Collection集合概述 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素 JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现 Collection集合基本使用
Java学习笔记day16-集合-List
在每个领域闪耀
01-01 693
Day16 集合 集合和数组的对比 数组的长度是不可变的，集合的长度是可变的。 数组可以存基本数据类型和引用数据类型。集合只能存引用数据类型，若要存基本数据类型，需要存对应的包装类。 集合类体系结构 Collection集合概述和使用 概述 是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素 JDK不提供接口的任何直接实现，它提供更具体的子接口实现 创建Collection集合的对象 多态的方式 具体的实现类ArrayList Collection集合常用方法
【Day12-Stream流&Map集合】
吾常自闭的博客
03-18 2852
一、Stream流 流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据，流讲的是计算！” Stream 自己不会存储元素，Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。 一般开发的套路是：创建一个Stream：一个数据源（数组、集合）-->中间操作：一个中间操作，处理数据源数据-->终止操作：一个终止操作，执行中间操作链，产生结果。 1、JDK1.8中
Day16-集合（上）List、Set、迭代器、泛型、比较器
热门推荐
qq_39746596的博客
01-29 2万+
文章目录集合一、概念二、特点三、集合 vs 数组四、集合家族Collection家族 -- 接口List家族 -- 接口Set家族 -- 接口Map家族五、迭代器六、泛型限定七、比较器注意事项 集合 一、概念 含义：一组数据的容器，跟数组类似 二、特点 集合是Java API所提供的一系列类，可以用于动态存放多个对象。–集合只能存对象 集合与数组的不同在于，集合是大小可变的序列，而且元素类型可以不受限定，只要是引用类型。(集合中不能放基本数据类型，但可以放基本数据类型的包装类) 集合类全部支持泛型
Day012--java中的Collection及Map集合（接口）常用实现类
码到成龚的博客
04-24 2041
Collection接口及Map接口的实现及常用方法。
Day13-【Java SE进阶】集合框架（一）Collection：List:ArrayList LinkedList ； Set:HashSet LinkedHashSet TreeSet
没有人的博客
03-01 1502
Set系列集合特点:无序:添加数据的顺序和获取出的数据顺序不一致;Collection单列集合：Collection代表单列集合，每个元素(数据)只包含一个值。Collection是单列集合的祖宗，它规定的方法(功能)是全部单列集合都会继承的。特点:查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的。存储、组织数据的方式不同的。Set要用到的常用方法，基本上就是Collection提供的!链表的特点1:查询慢，无论查询哪个数据都要从头开始找。List系列集合特点:有序，可重复，有索引。
22_23集合【Collection家族(list,set)、泛型、迭代器及其底层原理*、比较器接口】
gangain的博客
03-06 1240
1.集合2.泛型3.手撕迭代器底层4.Collection家族（1）List接口和ArrayList使用一致栈模式、队列模式Vector：和ArrayList的数据结构一致（一维数组），但是Vector是线程安全的（加锁）Vector有老的方法Stack：Vector的子类栈模式（2）Set接口HashSet：数据结构：一维数组+单向链表特点：无序+去重注意：理解为什么无序，为什么去重数据结构：一维数组+单向链表+双向链表特点：有序+去重。
JavaSE基础学习day3--异常&&集合
m0_75058032的博客
02-04 1080
异常：就是程序出现了不正常的情况异常体系：Error：问题严重，不需要处理Exception：称为异常类，他表示程序本身可以处理的问题RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码非RuntimeException：编译期间就必须处理，否则不能通过编译，更无法运行格式:public class 异常类名 extends Exception{无参构造带参构造案例：检查分数是否在0-100范围内的异常//定义异常类//定义老师类。
Day13-14：集合（Collection接口和Map接口）、Comparator接口、Collections工具类
亲爱的瑶的博客
05-13 6178
一.集合 集合：Java API所提供的一系列类，可以用于动态存放多个对象。 集合类全部支持泛型，是一种数据安全的用法。 LinkedList<String>list = new LinkedList<>(); 集合与数组不同在于： 1.集合是大小可变的序列，数组一旦声明长度不可变 2.同一个集...
day05-集合1
08-04
`Collection`接口是单元素集合的基类，它包括了如`List`、`Set`等子接口。`List`接口代表有序的集合，允许有重复元素；`Set`接口则代表无序且不包含重复元素的集合。这些接口提供了多种实现类，例如`ArrayList`、`...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 2259
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 984
浅析synchronized锁升级的原理与实现
《深入理解 Java 中的适配器模式》
面团到油条的成长日记
08-29 7094
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
数据访问：JPA
最新发布
hhgh_的博客
09-02 634
其二，Sun希望整合ORM 技术，实现统一的 API调用接口。@Table（name=“”,catalog=“”,schema=“”）可选，用来标注一个数据库对应的实体类，数据库中创建的表明默认和类名一致，通常和@Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息。@Entity(name=“EntityName”)必须，用来标注一个数据库表对应的实体，数据库中创建的表明默认和类名一致，其中，name可选，对应数据库中的一个表，使用此注解标记Pojo是一个JPA实体。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 210
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
操作系统原子操作
zzt_is_me的博客
08-28 7817
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值