安卓集训营第四天---JAVA基础数组和排序，枚举，内部类

1. Moudle为模块，并不能代替Elipes的工程

（IDEA在运行一个Moudle时会编译下面所有的Moudle，所有Moudle并不相互独立，一个报错另一个便无法执行）

 

2. 类必须有所属包，否则无法被导入

 

3. 数组在内存中是连续的内存空间，在初始化时大小便已经固定了（不可改变）；

数组除了其中基本数据类型，还可以有引用数据类型（类和接口）；

 

4. 三种声明数组的方法

New int[10];申请十个int的内存空间，并初始化所有的元素为0；

Int[] a={1，2，3}，只能在声明时使用；

a=New int[]{1,2,3,4}可以在非声明时使用

 

5. Random random = new Random(System.currentTimeMillis());

//给当前时间作为随机种子，令每次的随机数都不一样

For(int I =0;i<a.length;i++){

a[i]=random.nextInt(100);

}                             //随机[0,100)

 

6. For each语句遍历:只能循环不能赋值，只能用于访问

for（int i：a）{

System.out.println(i);

}

 

插入，选择，冒泡，排序：

 

1. 交换方法(黑客法)：

Privte static void swap（int[] a,int I,int j）{

a[i] ^[i] ^= a[j];

 

//a[i] = 0b10 , a[j] = 0b11;

a[j] ^= a[i];

 

//a[i] = 0b01 , a[j] = 0b11;

a[i] ^= a[j];

 

//a[i] = 0b01 , a[j] = 0b10;

      // a[i] = 0b11 ,  a[j] = 0b10;

}

 

 

 

2. 选择排序（一次循环移动一个最值）

 

Private static void sort (int[]a){

for(inti=0;i<a.length-1;i++){

intmin=i;

for(intj=i+1;j<a.length;j++){

if(a[min]>a[j]){

min=j;

}

}

if(min!=i){

swap(a,i,min);

}

}

}

 

 

3. 插入排序（默认排序指针之前的数据都是排序好的）

        private static void sort2(int[] a) {

        for (int i = 1; i < a.length; i++) {

            for (int j = i - 1; j >= 0; j--){

                if (a[j + 1] < a[j]) {

                    swap(a, j + 1, j);

                } else {

                 break;

                }

                }

        System.out.println(Arrays.toString(a));

        }

        }

 

 

 

 

4. 冒泡：

privatestaticvoidsort3(int[]a){

for(inti=a.length-1;i>0;i--){

for(intj=0;j<i;j++){

if(a[j]>a[j+1]){

swap(a,j,j+1);

}

}

}

}

 

 

快速排序（使用最广泛）：随机从数组中选择一个中间值，将数组按大小分在两边，再分别从两边中再取出随机数，以此类推：

privatestatic void qsort(int[] a) {

        qsort(a, 0, a.length - 1);

    }

    private static void qsort(int[] a, intstart, int end) {

        if (start >= end) {

            return;

        }

        int index = random.nextInt(end - start+ 1) + start;

        swap(a, index, end);

        index = start;

        for (int i = start; i < end; i++) {

            if (a[i] < a[end]) {

                swap(a, index, i);

                index++;

            }

        }

        swap(a, index, end);

        qsort(a, start, index - 1);

        qsort(a, index + 1, end);

    }

 

}

 

 

5. JAVA提供的排序方法：

Arrays.sort(a，Comparator);                   //传入数组和构造器

Arrays.sort(a,(o1,o2)->o2-o1);               //构造器属于单方法接口可以使用Lambda;  

System.out.println("排序之后");

for(inti:a){

System.out.println(i);

}

}

 

 

 

 

枚举（引用数据类型）

 

1. 定义一些不太好定义的类型

 

2. Public emnu Gender {

Male,fmale；//默认private的两个枚举值

}

Male,fmale枚举值之后可以添加属性和方法

在主类的set方法中传入Gender.Male或者Gender.fmale。

 

3. 枚举可以作为switch语句的参数，

Switch(Human.getGender()){

Case Male:…..;

Case Fmale:….;

}

 

4. 数组，类直接打印结果：类型@哈希Code

枚举默认有ToString()方法

 

5. 枚举类型不能被NEW，在写类的时候就已经被固定了

 

6. 枚举也有构造方法，枚举中的方法可以被重写。

例：用构造方法给枚举类值添加属性，并重写其方法；

 

Public enumGender{

MALE("男性"){

@Override

Public StringgetChinese(){

Return "重写getChinese()";

}

},FEMALE("女性");

Private Stringchinese="中文名";

Gender(Stringchinese){

this.chinese=chinese;

}

publicStringgetChinese(){

returnchinese;

}

}

 

 

 

单例模式（懒汉和饿汉）：

1. 系统中一个类只有一个实例

 

2. 懒汉式（用到的时候再调用）：

Public staticHumangetInstance(){

If(instance == null){

Instance = new Human();

}

Return instance;

}

 

*再static后加锁修饰（synchronized），防止多new对象

 

3. 饿汉式

先声明(静态方法块)

Public class Human{

Private static Human instance;

Static {

Instance = new Human();

 instance.setAge(18);

 instance.setHeight(1.7f);

 instance.setGender(Gender.MALE);

}

…

 

或

Private static human instance =new human();

 

*可以在static后面加轻量锁(volatile)防止多new对象。

 

 

 

5. 类被使用：1.类被第一次使用时

           2.调用类的属性和方法时

 

6. 以类的形式保证不了系统中只有一个类，所以单例模式只能用枚举

 

 

 

 

 

 

内部类：

1. 分为静态内部类（static）和动态内部类
2. 静态内部类和外面的类完全一样，静态内部类优势是可以访问外类的静态属性和方法，包括构造方法和私有方法；
3. 静态内部类中不能使用非静态变量；
4. 静态内部类可以用来实现构建者模式（

其核心思想是将一个“复杂对象的构建算法”与它的“部件及组装方式”分离，使得构件算法和组装方式可以独立应对变化。）

publicclass Test02 {

     public static void main(String[] args) {

        User user = newBuilder("user","123456").setEmail("[e-mail]").setAge(10).build();

        System.out.println(user.getUserName());

        System.out.println(user.getNickName());

        System.out.println(user.getEmail());

}

}

 

 

 

 

5. 动态内部类

创建一个内部类对象的时候一定要先有一个外部类对象；

可以访问外部类所有方法和属性；

在非静态在内部类中，this为内部当前对象，外部类.this为外部类的当前对象；

 

6. $一般不用，内部类和外表类的分割

 

7. 匿名内部类

匿名内部类，没有名字，只能创建一个对象；

在匿名内部类中新定义的方法和属性不能在外部使用；

内部类是否为静态和创建他的方法一样；