集合与数组、lambda

一、集合与数组

1、集合转数组toArray()

 String[] array=c.toArray(new String[c.size()]);
 //String[] array=c.toArray(new String[0]);//不占用空间
 System.out.println(Arrays.toString(array));//[one, two, three, four, five]
   重载的toArray方法要求我们传入一个需要转换的数组长度通常与集合size一致即可。如果数组长度小于集合size,那么toArray方法内部会创建一个与该数组类型且与集合size等长的数组将其返回

2、数组转集合asList()

 asList方法内部:创建一个名为ArrayList的实例(注意，它不是java.util.ArrayList而是Arrays自己定义的一个内部类)。该实例会直接引用传入的数组，因此对该集合的操作就是对该数组的操作。

 String[] array={"one","two","three","four","five"};
 List<String> list=Arrays.asList(array);
 System.out.println("list:"+list);//list:[one, two, three, four, five]
 list.set(2,"six");//对该集合的元素操作就是对原数组的元素操作
 //此时list和array都是[one, two, six, four, five]

注：因为数组定长，所以不支持改变长度的操作(如：list、remove)，会报错(不支持操作异常)UnsupportedOperationException，可以新建数组与原数组取并集，差集

 /*List<String> list2=new ArrayList<>();
 list2.addAll(list);*///与下一句效果一样
 List<String> list2=new ArrayList<>(list);
 list2.add("seven");
 list2.removeAll(list);

3、sort()、shuffle()--排序 (Collections)

①普通排序

 //java.util.Collections是集合的工具类，提供了很多static方法用于操作集合其中提供了一个名为sort的方法，可以对List集合进行自然排序(从小到大)
 Collections.sort(list);//从小到大
 shuffle()//乱序
 Collections.sort(list, new Comparator<Integer>() {
   public int compare(Integer o1, Integer o2) {
     return -(o1-o2);
   }
 });//倒序输出 

②集合排序

 //sort方法在排序时要求集合元素必须实现:Comparable接口
 compare:比较
 //开发中我们定义的类不会去实现Comparable接口。原因:
 该排序功能对我们的代码具有侵入性。
 //侵入性:
     当我们使用某个API功能是，其放过来要求我们为它实现接口或做某些继承
 并定义相关方法时，可以认定，该API功能对我们的代码具有侵入性。

 Comparator是Java中一个接口，它定义了用于比较两个对象的方法。
 Comparator接口通常用于对集合中的元素进行排序。

 Collections.sort(list,new Comparator<Point>() {
     public int compare(Point o1,Point o2){
         int olen1=o1.getX()*o1.getX()+o1.getY()* o1.getY();
         int olen2=o2.getX()*o2.getX()+o2.getY()* o2.getY();
         return olen1-olen2;
     }
 });

③字符串排序

Collections.sort(list, new Comparator<String>() {
    public int compare(String o1, String o2) {
        return o1.length()-o2.length();
        // return -(o1.length()-o2.length());//倒序输出
    }
});

二、lambda----箭头函数

//lambda表达式实际上是编译器认可的，最终会被改回为内部类方式创建
//源代码中使用lambda可以更突出重点-原匿名内部类中重写方法的逻辑。

1、sort()---排序

注：在java中可以使用lambda表达式代替匿名内部类创建所需要实现的接口时，该接口上都有一个注解:@FunctionalInterface

(参数列表)->{
    方法体
}//当使用匿名内部类创建时，如果实现的接口只有一个抽象方法，则可以使用lambda表达式代替

Comparator<String> c1=new Comparator<String>() {
    public int compare(String o1, String o2) {
        return o1.length()-o2.length();
    }
};
//lambda表达式就是省去了匿名内部类创建是接口与方法名部分，初步lambda后：
Comparator<String> c2=(String o1, String o2)->{
        return o1.length()-o2.length();
};
//lambda表达式可以忽略参数的类型，最终lambda后：
Comparator<String> c3=(o1, o2)->{
	return o1.length()-o2.length();
};

//如果方法中只有一句代码时，该方法体的“{}”可以忽略不写，如果这句代码含有return关键字时，也要一起忽略return
Comparator<String> c4=(o1, o2)-> o1.length()-o2.length();
//list有自己的sort方法，可以直接传入一个比较器来定义比较规则
list.sort((o1,o2)->o1.length()-o2.length());
	JDK8之后，List集合自己推出了一个sort方法，可以排序自身元素，并且需要传入一个比较器来定义比较规则。

2、foreach()---遍历(迭代器)

//JDK8之后，java在集合Collection接口中添加了一个用于遍历集合元素的forEach方法。可以基于lambda表达式遍历集合元素。

Consumer<String> consumer=new Consumer<String>() {
	public void accept(String e) {
		System.out.println(e);
	}
};
//tips:当lambda中只有一个参数时，参数列表的"()"可以忽略不写
c.forEach(e-> System.out.println(e));//遍历数组或集合

//JDK8中出现的lambda表达式的变种写法:方法引用
		对象::方法
当lambda表达式的参数与方法体中调用方法的参数一致时
   例如:(e)->System.out.println(e);
那么就可以写作:
   System.out::println;
//c.forEach(System.out::println);
匿名内部类lambda表达式中的局部变量必须为final的;若想使用可变的局部变量，需重新定义为静态局部变量
final String mes=message;
allOut.forEach(e->e.println(host+"说:" + mes));    

 

总结

集合与数组

集合转数组toArray()

数组转集合asList()

sort()、shuffle()--排序 (Collections)

lambda

sort()---排序

foreach()---遍历(迭代器)