JavaSE

数组

一维数组

数组是相同类型数据的有序集合：

public static void main(String[] args){
 	int[] array=new int[10];
 	//在创建数组时，需要指定数组长度
 }

静态初始化：

类型[] 变量名称=new 类型[]{...};
类型[] 变量名称={...};

创建出来的数组每个位置上都有默认值，如果是引用类型，就是null，如果是基本数据类型，就是0，或者是false。
访问数组的某一个元素：

System.out.println("数组的第一个元素为："+array[0]);
//使用变量名[下标]的方式访问

使用array.length访问数组的长度

二维数组

public static void main(String[] args){
 	int[][] array=new int[2][10];
 }

可变长参数

public class Person{
	String  name;
	int age;
	String sex;
	public void test(String...strings){
	}
}

在使用时，可以传入0-N个对应类型的实参：

public static void main(String[] args){
	Person p=new Person();
	p.test=("10","ok");
	}

实际上可变长参数本质就是一个数组：

public void test(String...strings){
	for(String s:strings){
	System.out.println(s);//遍历打印数组中的每一个元素
	}
}

字符串

String类

String本身也是一个类，每个用双引号括起来的字符串，都是String类型的一个实例对象：

public static void main(String[] args){
	String str="Hello World";

判断两个字符串的内容是否相同，不要使用==，String类重载了equals方法用于判断和比较内容是否相同：

public static void main(String[] args){
	String str1=new String("hello");
	String str2=new String("hello");
	System.out.println(str1.equals(str2));

str.length()方法可以求字符串的长度
其他方法：

String str="hello";
String sub=str.substring(0,3);
//分割字符串，并返回一个新的字符对象
System.out.println(sub);

String str="hel lo";
String[] strings=str.split(" ");
//通过空格分隔，得到一个字符串数组
for(String s:strings)
System.out.println(s);

String str="hello";
char[] a=str.toCharArray();
System.out.println(a[0]);

内部类

成员内部类

public class Test{
   public class Inner{
   public void test(){
		System.out.println("我是成员内部类");
		}
	}
}

成员内部类和成员方法、成员变量一样，是对象所有的，而不是类所有的，使用成员内部类：

public static void main(String[] args){
	Test test=new Test();//创建对象
	Test.Inner inner=test.new Inner();

静态内部类

静态内部类就像静态方法和静态变量，是属于类的，可以直接创建使用：

public class Test {
    private final String name;
    public Test(String name){
        this.name=name;
    }
    public static class Inner{
        public void test(){
            System.out.println("我是静态内部类！");
        }
    }
}

public  class Main {
        public static void main(String[] args) {
     Test.Inner inner=new Test.Inner();
     //静态内部类的类名同样是之前的格式，但是可以直接new了
            inner.test();
        }
    }

局部内部类

局部内部类就像局部变量一样，可以在方法中定义：

public class Test {
    private final String name;
    public Test(String name){
        this.name=name;
    }
        public void hello(){
        class Inner{
         //直接在方法中创建局部内部类
        }
    }
}

在方法中声明的类，作用范围只能在方法中：

public class Test {
        public void hello(){
        class Inner{
         //跟局部变量一样，先声明后使用
         	public void test(){
         	System.out.println("我是局部内部类");
        }
    }
    Inner inner=new Inner();
    inner.test();
    }
}

匿名内部类

public abstract class Student(){
	public abstract void test();
}

正常情况下，要创建一个抽象类的实例对象，只能对其进行继承，先实现未实现的方法，然后创建子类对象
而我们可以在方法中使用匿名内部类，将其中的抽象方法实现，并直接创建实例对象：

public  class Main {
    public static void main(String[] args) {
        Student student = new Student() {
            //在new的时候，后面加上花括号，把未实现的方法实现了
            @Override
            public void test() {
                System.out.println("我是匿名内部类的实现");
            }
        };
        student.test();
    }
}

匿名内部类中可以使用类中的属性
接口也可以通过这种匿名内部类的形式，直接创建一个匿名的接口实现类。

Lambda表达式

如果一个接口中有且只有一个待实现的抽象方法，那么我们可以将匿名内部类简写为Lambda表达式：

public static void main(String[] args) {
       Study study= () -> System.out.println("我是学习方法");
        study.study();
    }
}

具体规范：

1. 标准格式：([参数类型 参数名称]…) ->{代码语句，包括返回值}
2. 和匿名内部类不同，Lambda仅仅支持接口，不支持抽象类
3. 接口内必须有且仅有一个抽象方法（可以有多个方法，但是必须保证其他方法有默认实现，必须留一个抽象方法出来）