week5总结

String

// 在堆中创建字符串对象”Java“
// 将字符串对象”Java“的引用保存在字符串常量池中
String s1 = "Java";
// 直接返回字符串常量池中字符串对象”Java“对应的引用
String s2 = s1.intern();
// 会在堆中在单独创建一个字符串对象
String s3 = new String("Java");
// 直接返回字符串常量池中字符串对象”Java“对应的引用
String s4 = s3.intern();
// s1 和 s2 指向的是堆中的同一个对象
System.out.println(s1 == s2); // true
// s3 和 s4 指向的是堆中不同的对象
System.out.println(s3 == s4); // false
// s1 和 s4 指向的是堆中的同一个对象
System.out.println(s1 == s4); //true

flush()和close()的区别

• flush():将流中的缓冲区缓冲的数据刷新到目的地中，刷新后，流还可以继续使用。
• close():关闭资源，但在关闭前会将缓冲区中的数据先刷新到目的地，否则丢失数据，然后在关闭流。流不可以使用。如果写入数据多，一定要一边写一边刷新，最后一次可以不刷新，由close完成刷新并关闭。

常用字符编码所占字节数？

utf8 :英文占 1 字节，中文占 3 字节，unicode：任何字符都占 2 个字节，gbk：英文占 1 字节，中文占 2 字节

集合

Collection接口虽然继承了Iterable接口，但是集合的最顶层依然是Collection接口，而非Iterable接口，因为Iterable接口并不规范数据的存储，而只是规范了集合元素的迭代。

LIst集合下的contains方法检查元素是否重复

ArrayList的contains方法判断元素是否存在，判断的原理如下：

ArrayList的contains方法被调用时，用传入元素的equals方法依次与集合中的旧元素进行比较，根据返回的布尔值判断是否有重复元素。此时，当ArrayList存放自定义类型时，由于自定义类型在未重写equals方法前，判断是否重复的依据是地址值，所以如果想根据内容判断是否为重复元素，需要重写元素的equals方法。

如果想要判断arrayList中两个有相同的值但是地址值不同，需要在类中重写equals()与hashCode()方法

Collection.sort(如果比较对象必须重写比较器并且继承)

• Teacher类未重写equals方法前，判断集合中是否包含指定的老师

public static void main(String[] args) {
    //1：创建两个工号和姓名相同老师对象
    Teacher t1 = new Teacher("02", "刘邦");
    Teacher t2 = new Teacher("02", "刘邦");

    //2：创建老师集合
    List<Teacher> list =new ArrayList<Teacher>();

    //3：向集合中添加t1老师
    list.add(t1);

    //4：判断list集合中是否有t2老师
    System.out.println(list.contains(t2));//结果是false
}

第13行代码：t2调用equals方法与list集合中的每一个对象比较，默认比较内存地址编号。

• 重写Teacher类的equals方法，根据老师编号和姓名进行比较

class Teacher{
	//省略部分代码
    @Override
    public boolean equals(Object o) {
        if (null == o) return false;
        if(o instanceof Teacher){
            Teacher teacher = (Teacher) o;
            //根据老师工号和姓名判断两个老师是否相同
            if(teacher.no.equals(this.no) && teacher.name.equals(this.name)){
                return true;
            }
        }
        return false;
    }
}

Teacher类重写equals方法后，再次运行程序

public static void main(String[] args) {
    //1：创建两个工号和姓名相同老师对象
    Teacher t1 = new Teacher("02", "刘邦");
    Teacher t2 = new Teacher("02", "刘邦");

    //2：创建老师集合
    List<Teacher> list =new ArrayList<Teacher>();

    //3：向集合中添加t1老师
    list.add(t1);

    //4：判断list集合中是否有t2老师
    System.out.println(list.contains(t2));//结果是true
}

第13行代码：t2调用equals方法与list集合中的每一个对象比较，调用的是重写后的equals方法。

java.lang.Comparable接口就是自然比较器接口，该接口中有一个抽象方法int compareTo(T o)

• 若要实现集合中对象的排序，那么就必须让集合中存储的对象实现Comparable接口。重写比较方法int compareTo(T o)。在int compareTo(T o)方法内部进行自定义比较规则，比如按照总成绩比较，或者按照数学成绩比较。
• Collections类的sort方法在对集合中的元素进行排序时（例如集合中的第一个元素list.get(0)和第二个元素list.get(1)比较大小），会执行list.get(0).compare(list.get(1))。
• compareTo()方法返回值为int类型，根据返回结果确定对象大小：
  • 返回0，表示两个对象相等，
  • 返回负数，表示第一个对象小于第二个对象
  • 返回正数，表示第一个对象大于第二个对象。

现在为Student类添加自然比较器。

class Student implements Comparable<Student> {//实现自然比较器接口Comparable
	private String name;
	private int math;
	private int cn;
	public Student(String name, int math, int cn) {
		super();
		this.name = name;
		this.math = math;
		this.cn = cn;
	}
	
	public int getTotal() {
		return this.math+ this.cn;
	}
	//重写自然比较器方法compareTo()
	@Override
	public int compareTo(Student o) {
		return this.getTotal() - o.getTotal();//根据总成绩比较大小
	}
    //省略get /set 代码
}

再次测试程序，已经可以正常排序了。

运行结果：

总成绩：141，数学：71，语文:70
总成绩：152，数学：92，语文:60
总成绩：160，数学：80，语文:80
总成绩：170，数学：85，语文:85
总成绩：180，数学：90，语文:90

自然排序比较器小结：

• 如果集合中存储的是基本类型，那么Collections.sort()可以直接排序。

• 如果集合中存储的是引用类型，那么集合中存储对象所在的类就必须实现比较器接口Comparable。

方法引用

​ 方法引用：帮我们完成了接口实现，省去了我们自己定义Lamdba表达式

​ 如果一个类中的实现方法，其参数列表和返回值类型与某个函数式接口中的方法一致，那么可以使用方法引用的方式来代替Lambda表达式。Java编译器会利用函数式接口中方法的参数来调用引用的方法，并将该方法的返回值（如果有的话）作为接口方法的返回值。
​ 方法引用使用操作符“::”将对象或者类的名字与方法名分隔开。主要有以下三种形式：
● 对象::实例方法名
● 类名::静态方法名
● 对象::静态方法名

public class MyMath {
	public int increment(int num) {
		return ++num;
	}
	public static int decrement(int num ) {
		return --num;
	}
}

public class Test {
	public static void main(String[] args) {
		//lambda表达式
		Function<Integer, Integer> fun = (num)->{
			return ++num;
		};
		System.out.println(fun.apply(5));
		
		//使用方法引用:MyMath::decrement作为Function的方法实现
		//MyMath::decrement代替了(num)->{
		//	return ++num;
		//};
		Function<Integer, Integer> fun2 = MyMath::decrement;
		System.out.println(fun2.apply(5));
		
		//使用方法引用:mm::decrement作为Function的方法实现
		//mm::increment代替了(num)->{
		//	return ++num;
		//};
		MyMath mm = new MyMath();
		Function<Integer, Integer> fun3 = mm::increment;
		System.out.println(fun3.apply(5));
	}
}

:mm::decrement作为Function的方法实现
//mm::increment代替了(num)->{
// return ++num;
//};
MyMath mm = new MyMath();
Function<Integer, Integer> fun3 = mm::increment;
System.out.println(fun3.apply(5));
}
}