Collection<String> coll = new ArrayList<>();
coll.add("XXX");

// 1. 创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
coll.add("ddd");

// 2. 获取迭代器对象
Iterator<String> it = coll.iterator();

// 3. 利用循环不断的去获取集合中的每一个元素
while(it.hasNext()) {
    // 4. next方法的两件事情：获取元素并移动指针
    String str = it.next();
    System.out.println(str);
}

for(元素的数据类型 变量名: 数组或者集合){

}
// 示例：

// 1. 创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
// 2. 利用增强for进行遍历
// 注意点:
// s其实就是一个第三方变量，在循环的过程中依次表示集合中的每一个数据
for (String s : coll) {
    System.out.println(s);
}

// 1. 创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");

// 2. 利用方法引用优化遍历
coll.forEach(System.out::println);

// 1. 创建一个集合
List<String> list = new ArrayList<>();

// 2. 添加元素
list.add("aaa");
list.add("bbb");//1
list.add("ccc");

// void add(int index, E element) 在此集合中的指定位置插入指定的元素
// 细节: 原来索引上的元素会依次往后移
// list.add(1, "QQQ");

// E remove(int index) 删除指定索引处的元素，返回被删除的元素
// String remove = list.remove(0);
// System.out.println(remove);//aaa

// E set(int index, E element) 修改指定索引处的元素，返回被修改的元素
String result = list.set(0, "QQQ");
System.out.println(result);

// 3. 打印集合
System.out.println(list);

// 5. 列表迭代器
// 获取一个列表迭代器的对象，里面的指针默认也是指向0索引的

// 额外添加了一个方法: 在遍历的过程中，可以添加元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()){
    String str = it.next();
    if("bbb".equals(str)){
        // qqq
        it.add("qqq");
    }
}

修饰符<类型>返回值类型方法名(类型变量名){
}

修饰符 interface 接口名<类型>{
}

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        // 1. 创建 Set 集合对象
        Set<String> s = new HashSet<>();

        // 2. 添加元素
        s.add("张三");
        s.add("张三"); // 重复元素添加失败，返回 false
        s.add("李四");
        s.add("王五");

        // 3. 打印集合（无序）
        System.out.println(s); // 例如输出 [李四, 张三, 王五]

        // 4. 使用迭代器遍历
        Iterator<String> it = s.iterator();
        while (it.hasNext()) {
            String str = it.next();
            System.out.println(str);
        }

        // 5. 使用增强 for 遍历
        System.out.println("增强for循环遍历:");
        for (String str : s) {
            System.out.println(str);
        }

        // 6. 使用 Lambda 表达式遍历
        System.out.println("Lambda 表达式遍历:");
        s.forEach(str -> System.out.println(str));

        // 或者使用方法引用
        System.out.println("方法引用遍历:");
        s.forEach(System.out::println);
    }
}

@Data
public class Student{
    private String name;
    private int age;
}

// 1. 创建对象
Student s1 = new Student("zhangsan", 23);
Student s2 = new Student("zhangsan", 23);

// 2. 打印 hashCode（假设已重写 hashCode 方法）
System.out.println(s1.hashCode()); // 例如输出：-1461067292
System.out.println(s2.hashCode()); // 例如输出：-1461067292

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        // 1. 创建TreeSet集合对象
        TreeSet<Integer> ts = new TreeSet<>();

        // 2. 添加元素
        ts.add(4);
        ts.add(5);
        ts.add(1);
        ts.add(3);
        ts.add(2);

        // 3. 打印集合
        // System.out.println(ts);

        // 4. 遍历集合（三种遍历）

        // （1）迭代器遍历
        Iterator<Integer> it = ts.iterator();
        while (it.hasNext()) {
            int i = it.next();
            System.out.println(i);
        }

        // （2）增强for循环遍历
        for (Integer num : ts) {
            System.out.println(num);
        }

        // （3）Lambda表达式遍历
        ts.forEach(num -> System.out.println(num));
    }
}

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

    // 无参构造器
    public Student() {
    }

    // 带参构造器
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter 方法
    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;
    }

    // 重写 compareTo 方法，按年龄升序比较
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.age, other.age);
        // 如果需要先比较年龄，再比较姓名，可以这样写：
        // int ageCompare = Integer.compare(this.age, other.age);
        // if (ageCompare != 0) {
        //     return ageCompare;
        // }
        // return this.name.compareTo(other.name);
    }

    // 重写 toString 方法，方便打印对象信息
    @Override
    public String toString() {
        return "Student{name='" + name + '\'' + ", age=" + age + '}';
    }
}

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetComparatorDemo {
    public static void main(String[] args) {
        // 1. 创建集合，并传入自定义比较器
        // o1: 表示当前要添加的元素
        // o2: 表示已经在红黑树存在的元素
        // 返回值规则跟之前一样：负数表示o1 < o2，0表示相等，正数表示o1 > o2
       TreeSet<String> ts = new TreeSet<>((o1, o2) -> {
        int i = o1.length() - o2.length();
        return i == 0 ? o1.compareTo(o2) : i;
    });

        // 添加元素测试
        ts.add("apple");
        ts.add("banana");
        ts.add("pear");
        ts.add("grape");
        ts.add("kiwi");
        ts.add("orange");

        // 输出排序后的TreeSet
        System.out.println(ts);
    }
}

// 1. 创建Map集合的对象
Map<String, String> m = new HashMap<>();

// 2. 添加元素
// put方法的细节：
// 添加/覆盖
// 在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中
// 在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。

m.put("郭靖", "黄蓉");
m.put("韦小宝", "沐剑屏");
m.put("尹志平", "小龙女");

String value = m.put("韦小宝", "双儿");
System.out.println(value);


// 删除-remove
String result = m.remove( key:"郭靖");

// 清空-clear
m.clear();

// 判断是否包含-成功true失败false
boolean keyResult = m.containsKey("郭靖");
System.out.println(keyResult); // true

boolean valueResult = m.containsValue("小龙女2");
System.out.println(valueResult);

// 判断集合是否为空
boolean result = m.isEmpty();
System.out.println(result);

// 集合的长度，也就是集合中键值对的个数
int size = m.size();
System.out.println(size);


// 3. 打印集合
System.out.println(m);

public class A02_MapDemo2 {
    public static void main(String[] args) {
        // Map集合的第一种遍历方式

        // 1.创建Map集合的对象
        Map<String, String> map = new HashMap<>();

        // 2.添加元素
        map.put("尹志平", "小龙女");
        map.put("郭靖", "穆念慈");
        map.put("欧阳克", "黄蓉");

        // 3.通过键找值

        // 3.1获取所有的键，把这些键放到一个单列集合当中
        Set<String> keys = map.keySet();

        // 3.2遍历单列集合，得到每一个键
        for (String key : keys) {
            // System.out.println(key);
            // 3.3 利用map集合中的键获取对应的值 get
            String value = map.get(key);
            System.out.println(key + " = " + value);
        }
        
       // 使用迭代器的方式
        Iterator<String> iterator = keys.iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            String value = map.get(key);
            System.out.println(key + " = " + value);
        }
        // 使用Lambda表达式的方式遍历
        keys.forEach(key -> {
            String value = map.get(key);
            System.out.println(key + " = " + value);
        });
    }
}

public static void main(String[] args) {
    // Map集合的第二种遍历方式

    // 1.创建Map集合的对象
    Map<String, String> map = new HashMap<>();

    // 2.添加元素
    // 键：人物的外号
    // 值：人物的名字
    map.put("标枪连手", "马超");
    map.put("人物挂件", "明世隐");
    map.put("御龙骑士", "尹志平");

    // 3. Map集合的第二种遍历方式
    // 通过键值对对象进行遍历
    // 3.1 通过一个方法获取所有的键值对对象，返回一个Set集合
    Set<Map.Entry<String, String>> entries = map.entrySet();

    // 1. 增强for循环遍历键值对对象的单列集合
    Set<Map.Entry<String, String>> entries = map.entrySet();
    for (Map.Entry<String, String> entry : entries) {
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + " = " + value);
    }
    // 2. 迭代器形式遍历键值对对象的单列集合
    Iterator<Map.Entry<String,String>> iterator = entries.iterator();
    while(iterator.hasNext()) {
        Map.Entry<String,String> entry = iterator.next();
        System.out.println(entry.getKey() + " = " + entry.getValue());
    }
    // 3. lambda表达式遍历
    entries.forEach(entry -> {
        System.out.println(entry.getKey() + " = " + entry.getValue());
    });
}

public static void main(String[] args) {
    // Map集合的第三种遍历方式

    // 1. 创建Map集合的对象
    Map<String, String> map = new HashMap<>();

    // 2. 添加元素
    // 键：人物的名字
    // 值：名人名言
    map.put("鲁迅", "这句话是我说的");
    map.put("曹操", "不可能绝对不可能");
    map.put("刘备", "接着奏乐接着舞");
    map.put("柯镇恶", "看我眼色行事");

    // 3. 使用Lambda表达式遍历map
    map.forEach((key, value) -> System.out.println(key + " = " + value));
}

@Data
public class Student{
    private String name;
    private int age;
}

public class hashDemo{
    public static void main(String[] args){
        // 1. 创建集合
        HashMap<Student,String> hm new HashMap<>();
        
        // 2. 创建三个学生对象
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("wangwu", 25);
        
        // 3. 添加元素到Map集合
        Map<Student, String> hm = new HashMap<>();
        hm.put(s1, "江苏");
        hm.put(s2, "浙江");
        hm.put(s3, "福建");
        
        // 遍历集合
        // 1. 通过keySet遍历
        Set<Student> keys = hm.keySet();
        for (Student key : keys) {
            String value = hm.get(key);
            System.out.println(key + "=" + value);
        }

        System.out.println("----------------------------");

        // 2. 通过entrySet遍历
        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        
        // 3. Lambda表达式
        hm.forEach((Student,s)->System.out.println(student,s))
        
    }
}

// 1. 创建集合
LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();

// 2. 添加元素
lhm.put("c", 789);
lhm.put("b", 456);
lhm.put("a", 123);
lhm.put("a", 111);  // "a" 这个键对应的值会被更新为111

// 3. 打印集合
System.out.println(lhm);

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // 创建一个List
        List<Integer> list = new ArrayList<>(Arrays.asList(10, 1, 2, 4, 8, 5, 9, 6, 7, 3));

        // shuffle 打乱List集合元素的顺序
        Collections.shuffle(list);
        System.out.println("shuffle后: " + list);

        // sort 排序（自然顺序）
        Collections.sort(list);
        System.out.println("sort后: " + list);

        // sort 指定Comparator规则排序，降序排序示例
        Collections.sort(list, (a, b) -> b - a);
        System.out.println("sort(降序)后: " + list);

        // binarySearch 二分查找，查找元素5，返回索引，如果没找到返回负数
        Collections.sort(list); // binarySearch作用于已排序的list，先排序
        int index = Collections.binarySearch(list, 5);
        System.out.println("元素5的位置: " + index);

        // copy 拷贝集合中的元素，目标集合容量需大于等于源集合
        List<Integer> dest = new ArrayList<>(Collections.nCopies(list.size(), 0)); // 初始化目标集合容量
        Collections.copy(dest, list);
        System.out.println("copy后dest: " + dest);

        // fill 使用指定的元素填充集合
        Collections.fill(dest, 100);
        System.out.println("fill后dest: " + dest);

        // max/min 根据默认自然排序获取最大/小值
        int max = Collections.max(list);
        int min = Collections.min(list);
        System.out.println("最大值: " + max + ", 最小值: " + min);

        // swap 交换集合中指定位置元素
        Collections.swap(list, 0, list.size() - 1);
        System.out.println("swap后list: " + list);
    }
}

List<String> list = List.of("张三", "李四", "王五", "赵六");

System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));
System.out.println(list.get(3));

for (String s : list) {
    System.out.println(s);
}

System.out.println("--------------------------");

Iterator<String> it = list.iterator();
while(it.hasNext()){
    String s = it.next();
    System.out.println(s);
}
System.out.println("--------------------------");

import java.util.Map;
import java.util.HashMap;

public class ImmutableDemo {

    public static void main(String[] args) {
        // 1. 创建一个可变的HashMap，并放入数据
        HashMap<String, String> hm = new HashMap<>();
        hm.put("郑十", "苏州");
        hm.put("刘一", "无锡");
        hm.put("陈二", "嘉兴");
        hm.put("aaa", "111");

        // 2. 利用上面的数据来获取一个不可变的集合
        // 通过entrySet转换为数组后，调用Map.ofEntries创建不可变Map
        Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));

        // 尝试修改会抛出异常（这里注释，以免程序异常终止）
        // map.put("bbb", "222"); // UnsupportedOperationException

        // 打印不可变Map内容
        map.forEach((key, value) -> System.out.println(key + " -> " + value));
    }
}

import java.util.HashMap;

public class StreamDemo3 {
    public static void main(String[] args) {
        // 1. 创建双列集合
        HashMap<String, Integer> hm = new HashMap<>();

        // 2. 添加数据
        hm.put("aaa", 111);
        hm.put("bbb", 222);
        hm.put("ccc", 333);
        hm.put("ddd", 444);

        // 3. 第一种获取stream流
        // hm.keySet().stream().forEach(s -> System.out.println(s));

        // 4. 第二种获取stream流
        hm.entrySet().stream().forEach(s -> System.out.println(s));
    }
}

import java.util.Arrays;

public class StreamDemo4 {
    public static void main(String[] args) {
        // 1. 创建数组
        int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        String[] arr2 = {"a", "b", "c"};

        // 2. 获取stream流
        Arrays.stream(arr1).forEach(s -> System.out.println(s));

        System.out.println("==========================");

        Arrays.stream(arr2).forEach(s -> System.out.println(s));
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class StreamDemo {
    public static void main(String[] args) {
        // 创建并初始化一个ArrayList
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,
                "张无忌-男-15", "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
                "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");

        // ------------------- 任务一：收集到List集合当中 -------------------
        // 需求: 我要把所有的男性收集起来
        List<String> newList1 = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toList());

        System.out.println("收集到List中的男性（允许重复）: " + newList1);
        System.out.println("=========================================");


        // ------------------- 任务二：收集到Set集合当中 -------------------
        // 需求: 我要把所有的男性收集起来
        Set<String> newList2 = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toSet());

        System.out.println("收集到Set中的男性（自动去重）: " + newList2);
    }
     
    // 以姓名为key，年龄为value，收集男性。这里的key重复了会报错，因此用toMap第三个参数合并函数解决：
        Map<String, String> nameToAgeMap = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toMap(
                        s -> s.split("-")[0],          // key = 姓名
                        s -> s.split("-")[2],          // value = 年龄
                        (oldVal, newVal) -> oldVal     // key重复时，保留第一个
                ));
        System.out.println("姓名 -> 年龄 (男性): " + nameToAgeMap);
    /**
    list.stream()
    把list（一个字符串集合）转换成一个流，方便链式操作。
    .filter(s -> "男".equals(s.split("-")[1]))

    过滤操作，即只保留性别是“男”的字符串。
    s.split("-")是将字符串用“-”拆分成数组，形如[姓名, 性别, 年龄]。
    通过取[1]索引获得性别字段，判断是否等于"男"。
    只有满足此条件的字符串才会被保留进入下一步。
    .collect(Collectors.toMap(...))

    将流中剩余的元素收集为一个Map（键值对集合）。
    Collectors.toMap需要你指定：
    Key映射函数：给Map的key赋值；
    Value映射函数：给Map的value赋值；
    合并函数：当key重复时，如何处理
    */
}

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "1", "2", "3", "4", "5");

list.stream()
    .map(Integer::parseInt)
    .forEach(s -> System.out.println(s));

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");

list.stream()
    .filter(new FunctionDemo3()::stringJudge)
    .forEach(s -> System.out.println(s));

public boolean stringJudge(String s){
    return s.startsWith("张") && s.length() == 3;
}

File f1 = new File("D:\\aaa\\ddd\\a.txt");
boolean b = f1.createNewFile();
System.out.println(b);

import java.io.File;

public class Test2 {
    public static void main(String[] args) {
        /*
         * 需求:
         * 定义一个方法找某一个文件夹中，是否有以avi结尾的电影。
         * （暂时不需要考虑子文件夹）
         */
        File file = new File("D:\\aaa");
        boolean b = haveAVI(file);
        System.out.println(b);
    }

    /*
     * 作用: 用来找某一个文件夹中，是否有以avi结尾的电影
     * 形参: 要查找的文件夹
     * 返回值: 查找的结果  存在true  不存在false
     */
    public static boolean haveAVI(File file) { // D:\\aaa
        // 1.进入aaa文件夹，而且要获取里面所有的内容
        File[] files = file.listFiles();

        // 2.遍历数组获取里面的每一个元素
        for (File f : files) {
            // 3.判断是否是以avi结尾
            if (f.getName().endsWith(".avi")) {
                return true;
            }
        }
        return false;
    }
}

/*
    字节输出流的细节:
    1. 创建字节输出流对象
        细节1: 参数是字符串表示的路径或者是File对象都是可以的
        细节2: 如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
        细节3: 如果文件已经存在，则会清空文件
    2. 写数据
        细节: write方法的参数是整数，但是实际写到本地文件中的是整数在ASCII上对应的字符
        ‘9’
        ‘7’
    3. 释放资源
        每次使用完流之后都要释放资源
*/
// 1.创建对象
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
// 2.写出数据
fos.write(57);
fos.write(55);
// 3.释放资源
fos.close();

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class WriteExamples {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("myio\\example.txt");

        // 1. void write(int b) 一次写一个字节数据
        fos.write(65); // 写入字节'A' (ASCII 65)

        // 2. void write(byte[] b) 一次写一个字节数组数据
        byte[] bytes = {66, 67, 68}; // 对应 'B', 'C', 'D'
        fos.write(bytes);

        // 3. void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据
        byte[] moreBytes = {69, 70, 71, 72, 73}; // 对应 'E','F','G','H','I'
        // 从索引1开始写3个字节，也就是写 'F','G','H'
        fos.write(moreBytes, 1, 3);

        fos.close();
    }
}

package com.itheima.a01threadcase1;

/**
 * 多线程的第一种启动方式:
 * 1. 自定义一个类继承Thread
 * 2. 重写run方法
 * 3. 创建子类的对象, 并启动线程
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

package com.itheima.a01threadcase1;

public class MyThread extends Thread {
    @Override
    public void run() {
        //写线程要执行代码
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "HelloWorld");
        }
    }
}

package com.itheima.a02threadcase2;

public class ThreadDemo {
    public static void main(String[] args) {
        //创建MyRun的对象
        MyRun mr = new MyRun();
        //创建线程对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        //给线程设置名字
        t1.setName("线程1");
        t2.setName("线程2");
        //开启线程
        t1.start();
        t2.start();
    }
}

package com.itheima.a02threadcase2;

public class MyRun implements Runnable {
    @Override
    public void run() {
        //写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            //输出当前线程的名字和"HelloWorld!"
            System.out.println(Thread.currentThread().getName() + "HelloWorld!");
        }
    }
}