第六次实验室周报

从上次集合讲起

TreeSet ：Set接口有一个实现类：TreeSet类，该类底层使用红黑树算法（平衡二叉树）。
可以对集合中的数据按照一定的规则来排序。

public static void main(String[] args) {
        // 元素可以自动排序
        Set set=new TreeSet();
        set.add(10);
        set.add(5);
        set.add(0);
        System.out.println(set);

        set=new TreeSet();
        set.add("5");
        set.add("10");
        set.add("2");
        set.add("5");
        set.add("高数");
        set.add("线代");
        set.add("离散");
        System.out.println(set);// 结果：10, 2, 5, 离散, 线代, 高数 。 为什么10是第一位呢？因为是字符串，会先比较10中的1.

注意：使用TreeSet,一定要保证该集合中的元素必须是同一种数据类型。
只有同一种数据类型才有可比性，若数据类型不同，就会报错。

把某一对象存储在TreeSet中，对象的类通过实现Comparable接口才会具有可比性，否则报错（类型转换错误）。

第一种方法继承Comparable接口：

Comparable 接口：
方法：
public int compareTo( Object o ){
编写比较规则
}

拿当前对象(this)和传入的o对象作比较。
返回： 当前对象 > o : return 正整数;
当前对象 == o : return 0;
当前对象 < o : return 负整数;
TreeSet会认为，如果compareTo方法返回的是0，则认为是同一个对象，若是同一个对象则不会添加到集合中。

class Student1 implements Comparable{
       private String name;
       private int    age;
       private int    score;

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

    // 作比较
    @Override
    public int compareTo(Object obj) { // 父类要访问对象的成员变量，必须强转成子类
        Student1 other=(Student1)obj;
        if(this.score > other.score){
            return 1;
        }else if(this.score < other.score){
            return -1;
        }else{  // 如果成绩相同时则比较年龄
            if(this.age > other.age){
                return 1;
            }else if(this.age < other.age){
                return -1;
            }else{
                return this.name.compareTo(other.name); // 年龄和成绩都相同时，比较名字（String已实现compareTo方法）
            }
        }
    }

    @Override
    public String toString() {
        return "Studen1[name = "+name+",age = "+age+",score = "+score+"]";
    }
}

^父类要访问对象的成员变量，必须强转成子类。

第二种方法继承Comparator接口：

//根据名字长度来排序，长的先排出来，短的后排出来
class Teacher {
    private String name;
    public Teacher(String name){
        this.name=name;
    }

    public String getName() {
        return name;
    }

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

public class StudentSortDemo2 {
    public static void main(String[] args) {
        Comparator com=new NameCom();// 不用Comparable接口的原因是，其采用的是自然排序（从低到高）。Comparator 更多是自定义排序（例如名字有长短之分）
        Set set=new TreeSet(com);// com就相当于承载了你的自定义规则，并且给了TreeSet
        /*Set set=new TreeSet(new Comparator() {--------------->匿名内部类的方法
            @Override
            public int compare(Object o1, Object o2) {
                Teacher t1=(Teacher)o1;
                Teacher t2=(Teacher)o2;
                String name1=t1.getName();
                String name2=t2.getName();
                if(name1.length() > name2.length()){
                    return -1;
                }else if(name1.length() < name2.length()){
                    return 1;
                }
                return 0;
            }
        });*/
        set.add(new Teacher("will"));
        set.add(new Teacher("ajksjdhbk"));
        set.add(new Teacher("MA"));
        System.out.println(set);
    }
}

class NameCom implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        Teacher t1=(Teacher)o1;
        Teacher t2=(Teacher)o2;
        String name1=t1.getName();
        String name2=t2.getName();
        if(name1.length() > name2.length()){
            return -1;
        }else if(name1.length() < name2.length()){
            return 1;
        }
        return 0;
    }
}

^不用Comparable接口的原因是，其采用的是自然排序（从低到高）。Comparator 更多是自定义排序（例如名字有长短之分）。

TreeSet里面应用的排序规则( Comparable和Comparator接口 )：
Comparable：自然顺序排序（低–>高）：内比较器
比较Set集合中是否是同一个元素的标准。
compareTo方法是否返回0。
Comparator：自定义排序 ： 外比较器
比较Set集合中是否是同一个元素的标准。
compare方法是否返回0.

Map不是集合!
Map表示一种映射关系：
数学中的定义：有A和B两个集合，A集合中的一个元素，总能在B集合中找到唯一的一个映射值。（B集合中的一个元素，可以被A集合中的多个元素映射）。
Map:多个Entry的集合，一个Entry表示一个键值对，Map表示多个键值对，Map表示多组映射关系。

Map接口对应常用的实现类：
Hashtable类：在没有集合框架之前，就使用Hashtable来表示映射关系。现在建议使用HashMap类。通过源码可以看出，Hashtable中的每一个方法都是用synchronized修饰。

HashMap类：底层使用哈希表算法。底层没有用synchronized修饰。
HashMap相对于Hashtable来说，性能较高，但安全性较低。与ArrayList和Vector的区别相同。

LinkedHashMap类：保证Map中的key会记录添加顺序。
TreeMap类：保证Map中的key会按照指定的规则来排序。

通过观察Set和Map的体系，会发现很多实现类的名字相似（底层算法相同）。HashSet的底层就是使用HashMap。
在构建HashSet对象时，底层创建的是一个HashMap对象。
在把元素添加到set时，底层是存放在Map中的。
Map中的key其实就是Set的元素。
Map中所有的key其实就是Set集合。

集合工具类：
1：java.util.Arrays类：
Public static List asList(Object… params)：把一个数组转换成对应的List集合。
数组转换为List最便捷的方式：List Arrays.asList( Object… params )：其底层还是ArrayList,不过是其内部类。
注意：返回的List的长度是固定的，不能改变。不过，一旦转换成功，该集合就会定长，所以对list进行增加删减操作就会报错，但替换操作不会。

2：java.util.Collections类：操作集合的工具类。
ArrayList，HashSet，HashMap都是线程不安全的类。

// 得到一个线程安全的Set
Set set=Collections.synchronizedSet(new HashSet<>());
synchronized (set){
    // 对set对象的一些操作
}

但是我们平时不经常用，直接在Set方法上加入synchronized就行。
Collections的一些操作：

//返回空集：没有元素的集合
        List emptyList= Collections.EMPTY_LIST; // 常量
        System.out.println(emptyList);
        emptyList =Collections.emptyList();//方法
        System.out.println(emptyList);

        list=Arrays.asList(1,2,3,4,5,6);
        int index=Collections.binarySearch(list,5);//用二分法查找list中的元素，返回索引
        System.out.println(index);
        System.out.println(list);
        Collections.reverse(list);//对list里的元素从后往前翻转
        System.out.println(list);
        Collections.shuffle(list);//对list里的元素进行随机翻转
        System.out.println(list);

使用集合但不使用泛型所带来的问题：
1、编译器存在警告。
2、使用Tree类，如何保证只存储同一种数据类型(不是自己主动要求的那种类型)。
3、从集合中取出元素必须强转（或者使用Object）。
泛型：简概为广泛的通用类型，可以实现不同的调用者使用不同的数据类型。
若泛型不指明，就默认为Object类。
解决问题二：例如，想让TreeSet只存储String类型的元素：

Set<String> set = new TreeSet<String>();或Set<String> set = new TreeSet<>();

泛型通配符 ：? ------------不知道传什么类型。

public static void main(String[] args) {
        // 泛型通配符 ：? ------------不知道传什么类型
        List<Object> list1=null;
        List<Number> list2=null;
        List<Integer> list3=null;
        //dowork(list1); 该操作会报错，因为此时在限定泛型上限只接受 Number和其子类
        dowork(list2);
        dowork(list3);

        dowork1(list1);
        dowork1(list2);
        //dowork1(list3); 该操作会报错，因为此时在限定泛型下限限只接受 Number和其父类
    }
    static void dowork(List<? extends Number> list){ // 限定了泛型上限

    }
    static void dowork1(List<? super Number> list){ // 限定了泛型下限

    }

文件

I/O的类库都在java.io包中。---------->使用I/O的类库必须使用import引入。

Java . io . File类：表示了文件和目录。
Windows系统：表示路径使用\ 。
但是在java中，一根 \ 表示转义符，我们必须写成: \。
路径分割使用 ; 。
Unix 系统：表示路径使用/ ，但是windows也可以用。
路径分割使用 : 。
注意：File表示一个文件/一个文件夹的路径，一旦File对象创建成功，就只能表示指定的路径。

public static void main(String[] args) throws IOException {
        //创建File对象（使用前三个构造器）
        File f1=new File("E:/hello/read.txt");
        // 判断文件是文件夹（目录）还是文件
        if(f1.isDirectory()){
            System.out.println("是目录");
        }
        if(f1.isFile()){
            System.out.println("是文件");
        }
        //boolean exists()测试此抽象路径名表示的文件或目录是否存在。
        System.out.println(f1.exists());

         // 创建文件夹
       new File("E:/hello/read1.txt").createNewFile();//文件不存在时
        new File("E:/hello/t").mkdir();// 目录存在，尾目录不存在
        new File("E:/hello1/t1").mkdirs();//创建多级目录
       
        
        File f1=new File("E:/hello/read.txt");
        File f2=new File("E:/hello","read.txt");
        //                         路径名           文档名

        //使用File表示文件夹对象
        File dir=new File("E:/hello");
        File f3=new File(dir,"read.txt");
        

        //获取文件名称
        String fileName=f1.getName();
        System.out.println(fileName);
        //获取文件父目录
        String dir=f1.getParent();
        System.out.println(dir);
        //获取文件的路径（相对路径）：一般在该项目中找，够用
        System.out.println(f1.getPath());
        // 获取文件的绝对路径：不在项目中找，就要用这个
        System.out.println(f1.getAbsolutePath());
        // 获取最后一次修改时间
        System.out.println(f1.lastModified());
        //修改文件名：boolean renameTo(File dest)重新命名此抽象路径名表示的文件。
        f1.renameTo(new File("E:/hello/reads.txt"));
    }

获取当前目录的子文件:

//获取当前目录的子文件
public class FileDemo2 {
    public static void main(String[] args) {
        File file=new File("E:\\BaiduNetdiskDownload");
        File[] fs=file.listFiles();
        for(File f : fs){
            System.out.println(f);
        }
        System.out.println("--------------------------------------------------------");
        //使用递归：获取该目录下的所有文件以及子目录的所有文件
        //listAllFiles(file);

        //列出有哪些盘符
        File[] roots=file.listRoots();
        for(File f : roots){
            System.out.println(f);
        }
    }
    public static void listAllFiles(File file){
        System.out.println(file);
        if(file.isDirectory()) {
            File[] fs = file.listFiles();
            for( File files : fs){
                listAllFiles(files);
            }
        }
    }
}