0619内部类_Lambda

一、内部类

内部类就是 类内部的类。
内部类可以有private与protected权限，实现隐藏
内部类可以访问外部类的所有元素；可以实现多重继承；可以匿名内部类优化接口

唯一优点：内部类可以随意使用外部类的成员变量（包括private）而不用生成外部类的对象
形式如下：

public class Outter{  //外部类
	class Inner{  //成员内部类：成员内部类可以无条件访问外部类的所有成员属性和成员方法
	//（包括private成员和静态成员）
	 
	 }
	 public void test(){
	 	class Inner1{  //局部内部类
	    }
	 }
}

创建内部类实例

Out.Inner inner = new Out().new Inner();
//或
Out out = new Out()
Out.Inner inner = out.new Inner();

内部类分为：成员内部类、局部内部类、匿名内部类和静态内部类。
静态内部类
如果用static 将内部类静态化，那么内部类就只能访问外部类的静态成员变量，不能直接访问外部类的实例变量、 实例方法，只有通过对象引用才能访问。
其次，因为内部类被静态化，因此Out.In可以当做一个整体看，可以直接new 出内部类的对象（静态内部类不通过外部类实例进行创建对象）

**局部内部类：**像局部变量一样，不能被public, protected, private和static修饰。jdk1.8 +可以不加 final

**匿名内部类：**定义类的最终目的是创建一个类的实例，但是如果某个类的实例只是用一次，则可以将类的定义与类 的创建，放到与一起完成，或者说在定义类的同时就创建一个类 , 以这种方法定义的没有名字的类成为匿名内部类。
声明构造匿名内部类的一般格式：

new ClassOrlnterfaceName(){
//类体
}

Lambda ->

Lambda可以理解为一段可以传递的代码（将代码像数据一样进行传递）
左侧：Lambda表达式的参数列表。对应接口中抽象方法的参数列表。
右侧：Lambda表达式中所需要执行的功能，即Lambda体。对应接口中抽象方法的实现。

四大内置核心函数式接口

消费型、供给型、函数型、断定型
消费型接口 Comsumer
void accept(T t)
供给型接口 Supplier
T get()
函数型接口 Function<T,R>
R apply(T t)
断定型接口 Predicate
boolean test(T t)
消费型：只进不出

public void test1() {
    happy(10000, (m) -> System.out.println("澳门赌场一日游下去" + m + "元"));
     }
 public void happy(double money, Consumer<Double> con) {
     con.accept(money); }

供给型：白手起家，空手套白狼

/* Supplier<T> 供给型接口
 *T get();     
 */ 
 // 需求：产生指定个数的整数，并放入集合中 
 @Test 
public void test2() {
    List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
 
    for (Integer integer : numList) {
       System.out.println(integer);    
    } 
}
 
public List<Integer> getNumList(int num, Supplier<Integer> sup) {
    List<Integer> list = new ArrayList<>();
 
    for(int i = 0; i < num; i++) {
       Integer n = sup.get();        
       list.add(n);    
    }    
    return list; 
}

函数型：礼尚往来

/** Function<T, R> 函数型接口     
*     R apply(T t);     
* */ 
* // 需求：用于处理字符串 
* @Test
public void test3() {    
   String newStr = strHandler("  shsxt   ", (str) -> str.trim());               System.out.println(newStr); 

    newStr = strHandler("shsxt", (str) -> str.substring(2, 5));        System.out.println(newStr); }
 
public String strHandler(String str, Function<String, String> fun) {    
return fun.apply(str); 
}

断定型：鉴定评审

/*     
* Predicate<T> 断言型接口     
* *      boolean test(T t);     
* */ 
* // 需求：将满足条件的字符串，放入集合中 
public void test(){
    Predicate<Integer> pre = (i) -> i>1;
    System.out.println(pre.test(5)); }   
 
 public void test4() {    
    List<String> list = Arrays.asList("hello", "shsxt", "Lambda", "www", "ok");            									List<String> strList = filterStr(list, (s) -> s.length() > 3);
 
    for (String string : strList) {
        System.out.println(string);    
    } 
}
 
public List<String> filterStr(List<String> list, Predicate<String> pre) {
    List<String> strList = new ArrayList<>();
 
    for (String string : list) {  
       if(pre.test(string)) {        
         strList.add(string);        
       }    
     }
     return strList; 
}

Collections工具类

常用方法：

void sort(List) //对 List 容器内的元素排序,按照升序进行排序。 
void shuffle(List) //对 List 容器内的元素进行随机排列 
void reverse(List) //对 List 容器内的元素进行逆续排列 
void fill(List, Object) //用一个特定的对象重写整个 List 容器 
int binarySearch(List, Object)//采用折半查找的方法查找特定对象
List aList = new ArrayList(); 
for (int i = 0; i < 5; i++)  
  aList.add("a" + i); 
System.out.println(aList); 
Collections.shuffle(aList); // 随机排列 System.out.println(aList); 
Collections.reverse(aList); // 逆续 
System.out.println(aList); 
Collections.sort(aList);  // 排序 
System.out.println(aList); 
System.out.println(Collections.binarySearch(aList, "a2")); 
Collections.fill(aList, "hello"); 
System.out.println(aList)；

Comparable接口
所有可以“排序”的类都实现了java.lang.Comparable 接口，Comparable接口中只有一个方法
public int compareTo(Object obj);
该方法: 返回 0 表示 this == obj
返回正数表示 this > obj
返回负数表示 this < obj

Comparator 接口
Comparator比较器，可以根据需要定制特定的比较规则

Comparable接口

public class TestComparable {
 
/**     
* @param args     
* */    
  public static void main(String[] args) {   
     List<Student> list = new ArrayList<Student>();
     Student stu1 = new Student(1,"张三",100);
     Student stu2 = new Student(2,"张四",80);        
     Student stu3 = new Student(3,"张五",90);        
     list.add(stu1);        
     list.add(stu2);        
     list.add(stu3);        
     System.out.println(list);        
     Collections.sort(list);        
     System.out.println(list);            
  }
 
}
 
 class Student implements Comparable<Student> {    
    int id;    
    String name;    
    int score;        
  public Student(int id, String name, int score) {        
    super();        
    this.id = id;        
    this.name = name;        
    this.score = score;    
  }        
  public String toString(){        
      return name+score;    }
 
 @Override    
 public int compareTo(Student o) {    
     if(this.score>o.score){            
     return 1;        
     }else if(this.score<o.score){            
     return -1;        
     }else {            
     return 0;        
     }    
  } 
}

Comparator 接口

List<Student> stus = new ArrayList<Student>(){    
   {        
       add(new Student("张三", 30));         
       add(new Student("李四", 20));         
       add(new Student("王五", 60));     
   } 
}; 
//对users按年龄进行排序 
Collections.sort(stus, new Comparator<Student>() {
 
@Override    
    public int compare(Student s1, Student s2) {        
    // 升序        
    //return s1.getAge()-s2.getAge();        
    return s1.getAge().compareTo(s2.getAge());        
    // 降序        
    // return s2.getAge()-s1.getAge();        
    // return s2.getAge().compareTo(s1.getAge());    
    } 
});

还可以使用lambda表达式简化代码, 前提是JDK8开发环境,

List<Student> stus = new ArrayList<Student>(){    
    {        
        add(new Student("张三", 30));         
        add(new Student("李四", 20));         
        add(new Student("王五", 60));     
     } 
}; 
//对users按年龄进行排序 
Collections.sort(stus, (s1,s2)->(s1.getAge()-s2.getAge()));