java高级02，遍历、扩容、Collections

迭代器

1.通过集合调用Iterator()获取该集合的迭代器
2.通过迭代器的hashNext()方法判断是否有元素
3.如果有则通过next()方法获取该元素

List<News> list1 = new ArrayList<>();
Iterator<News> iterator = list1.iterator();
        while (iterator.hasNext()) {
            News next = iterator.next();
            System.out.println(next.getName() + " " + next.getId());
        }

遍历集合

List<News> list1 = new ArrayList<>();
Iterator<News> iterator = list1.iterator();
        while (iterator.hasNext()) {
            News next = iterator.next();
            System.out.println(next.getName() + " " + next.getId());
        }
//增强for循环 foreach循环
for (News news : list1) {
        System.out.println(news.getName() + " " + news.getId());
        }
    //set遍历
        Set<String> set = new HashSet<>();
        set.add("A");
        set.add("B");
        set.add("C");
        set.add("D");
        for (String s : set) {
            System.out.println(s);
        }
        System.out.println("------------");
        for(int i=0;i<set.size();i++){
            System.out.println(set.toArray()[i]);
        }
        System.out.println("------------");
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //Map遍历
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "张三");
        map.put(2, "李四");
        map.put(3, "王五");
        map.put(4, "赵六");
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // 遍历键
        for (Integer key : map.keySet()) {
            System.out.println("Key: " + key);
        }
        // 遍历值
        for (String value : map.values()) {
            System.out.println("Value: " + value);
        }
//得到键值对，再分别取出键和值
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
//先得到全部的键，再通过键来取到值
        Iterator<Integer> keyIterator = map.keySet().iterator();
        while (keyIterator.hasNext()) {
            Integer key = keyIterator.next();
            System.out.println("Key: " + key+", Value: " + map.get(key));
        }

ArrayList扩容机制

Java中的ArrayList扩容，在使用add()方法存放数据时，会调用ensureCapacityInternal方法来确保数组有足够的容量来容纳新元素。如果当前容量不够，则会自动扩容。在未指定长度时，集合长度默认是10，超过时会使用grow()方法进行扩容，每次1.5倍，最大长度不超过MAX_ARRAY_SIZE。扩容后调用copyOf()方法将原集合数据放到扩容后的新数组中，再赋回给原数组。

扩容触发条件
添加元素时：当使用 add 方法添加元素时，如果当前数组已满（即 size 等于 elementData.length），则触发扩容。
初始化时：如果创建 ArrayList 实例时没有指定初始容量或指定的容量太小，那么默认容量为10。
扩容策略
默认初始容量：如果创建 ArrayList 时未指定初始容量，那么默认容量为10。
扩容比例：每次扩容时，新的容量通常是原有容量的1.5倍。

//这是最常用的add方法，它的实现如下：
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
扩容机制的核心代码实现：
// 确保有足够的容量
private void ensureCapacityInternal(int minCapacity) {
    if (minCapacity - elementData.length > 0) {
        grow(minCapacity);
    }
}

// 扩容方法
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5倍
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        newCapacity = hugeCapacity(minCapacity);
    }
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

// 处理大容量的情况
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

ensureCapacityInternal 方法：这个方法用于检查当前的容量是否足够。如果不够，它会调用 grow 方法来进行扩容。
grow 方法：该方法负责计算新的容量并创建一个新的数组。新容量通常是原容量的1.5倍，但不会超过 MAX_ARRAY_SIZE。
hugeCapacity 方法：当需要的最小容量大于 MAX_ARRAY_SIZE 时，会调用此方法来处理。如果仍然不足，那么新的容量将是 Integer.MAX_VALUE。

Collections

 public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(8);
        list.add(2);
        list.add(9);
        list.add(4);
        list.add(5);
        System.out.print("排序前：");
        for(Integer i : list){
            System.out.print(i+" ");
        }
        System.out.println();
        //升序排序
        Collections.sort(list);
        System.out.print("升序排序后：");
        for(Integer i : list){
            System.out.print(i+" ");
        }
        System.out.println();
        //降序排序
        Collections.reverse(list);
        System.out.print("降序排序后：");
        for(Integer i : list){
            System.out.print(i+" ");
        }
        System.out.println();
        //随机排序
        Collections.shuffle(list);
        System.out.print("随机排序后：");
        for(Integer i : list){
            System.out.print(i+" ");
        }
        System.out.println();
        //二分查找，使用前需要排序,返回值时下标
        Collections.sort(list);
        int index = Collections.binarySearch(list, 5);
        System.out.println("二分查找5的索引位置："+index);
        //查找最大值和最小值
        int max = Collections.max(list);
        int min = Collections.min(list);
        System.out.println("最大值："+max);
        System.out.println("最小值："+min);

    }

重写Comparable接口的compareTo()方法

public class Student implements Comparable {
    private String name;
    private int age;
    private String gender;

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
重写根据年龄排序
@Override
    public int compareTo(Object o) {
        if (o instanceof Student){
            Student s = (Student)o;
            return this.age - s.getAge();
        }
        return 0;
    }
//重写根据年龄排序若年龄相等则按学号排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof Student){
            Student s = (Student)o;
            if(this.age == s.getAge()){
                return this.id - s.getId();
            }else {
                return this.age - s.getAge();
            }
        }
        return 0;
    }
}
//测试
        Collections.sort(students);
        System.out.print("按照年龄排序后的学生列表：");
        for(Student student : students){
            System.out.print(student.getName()+" ");
        }