# 数组进阶

## System.arraycopy 数组拷贝

System类中提供arraycopy方法来进行数组拷贝。

源码：

![](/files/-LxV8XMo1mQHVBTjwReg)

* src：目标数组 
* srcPos：从目标数组的某下标位置开始拷贝
* dest：新数组
* destPos：从新数组的某下标位置开始存放。
* Length：（从目标数组的某下标位置开始拷贝）指定将目标数组的多少个元素赋给新数组的元素。

代码：

```java
public static void main(String[] args) {  
    TestArray.copyTest();  
}  

public static void copyTest(){  
    int[] aa = {11,22,33,44,55,66};  
    int[] bb = new int[8];  
    // 从数组aa的下标2位置开始拷贝4个元素给bb数组，并从bb数组的下标3位置开始存放。  
    System.arraycopy(aa, 2, bb, 3, 4);  
    for(int i=0; i<bb.length; i++){  
        System.out.println(i+"--"+bb[i]);  
    }  
}
```

效果：

![](/files/-LxV8ov7v14rqjVY7Cnz)

示例:

```java
public class CopyArr {  
    public static void main(String[] args){  
        //删除  
        String[] s = {"aa","bb","cc","dd","ee"};  
        del(s,1);  
        insert(s, 5,"ff");  
    }  
    //删除任意位置的一个元素，并打印新数组  
    public static void del(String[] s, int index){  
        String[] s1 = new String[s.length-1];  
        //拷贝两次，一次是从index前面的下标开始拷贝，一次是从index后面的下标开始拷贝  
        //前面  
        System.arraycopy(s,0,s1,0,index);  
        //后面  
        System.arraycopy(s,index+1,s1,index,s1.length-index);  
        System.out.println(Arrays.toString(s1));  
    }  
    //插入任意位置的一个元素，并打印新数组 str代表插入内容，index代表插入下标  
    public static void insert(String[] s, int index, String str){  
        String[] s1 = new String[s.length+1];  
        //插入内容到新数组  
        s1[index] = str;  
        //也是拷贝两次，一次前面，一次后面  
        System.arraycopy(s,0,s1,0,index);//前面  
        System.arraycopy(s,index,s1,index+1,s.length-index);//后面  
        System.out.println(Arrays.toString(s1));  
    }  
}
```

效果:

![](/files/-LxV8zv_JZCuThxJbl-8)

#### 删除，本质是拷贝。

代码：

```java
String[] s = {"成都","重庆","上海","北京","天津"};  
   TestArray.copyTest1(s, 2);  
}  

// 删除数组s的指定元素index，并把原数组返回。  
public static void copyTest1(String[] s, int index){  
   /*从数组aa的下标index后一位的位置开始index+1拷贝s.length-index-1个元素给aa数组， 
   并从aa数组的下标index位置开始存放。*/  
   System.arraycopy(s, index+1, s, index, s.length-index-1);  
   // 下标s.length-1的值还是原来的值，我们要把它赋值为空，如果不这样做，运行会出现s[s.length-1]的值与s[s.length-2]的值一样  
   s[s.length-1] = null;  
   for(int i=0; i<s.length; i++){  
      System.out.println(i+"--"+s[i]);  
   }  
}
```

效果：

![](/files/-LxV9J6HPVwIStktjcpv)

#### 扩容，本质是拷贝。

代码：

```java
TestArray.copyTest2();  
}  
// 把数组原封不动的转移到一个更大的数组上。  
public static void copyTest2(){  
    int[] aa = {11,22,33,44,55,66};  
    int[] bb = new int[8];  
    System.arraycopy(aa, 0, bb, 0, aa.length);  
    for(int i=0; i<bb.length; i++){  
        System.out.println(i+"--"+bb[i]);  
    }  
}
```

效果：

![](/files/-LxV9W1vecMHKaaE858N)

完整代码：

```java
package com.itcode.demo2;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 *  数组拷贝 
 */  

public class TestArray {  
    public static void main(String[] args) {  
//      TestArray.copyTest();  
//      String[] s = {"成都","重庆","上海","北京","天津"};  
//      TestArray.copyTest1(s, 2);  
        TestArray.copyTest2();  
    }  
    // 把数组原封不动的转移到一个更大的数组上。  
    public static void copyTest2(){  
        int[] aa = {11,22,33,44,55,66};  
        int[] bb = new int[8];  
        System.arraycopy(aa, 0, bb, 0, aa.length);  
        for(int i=0; i<bb.length; i++){  
            System.out.println(i+"--"+bb[i]);  
        }  
    }  

    // 删除数组s的指定元素index，并把原数组返回。  
    public static void copyTest1(String[] s, int index){  
        /*从数组aa的下标index后一位的位置开始index+1拷贝s.length-index-1个元素给aa数组， 
        并从aa数组的下标index位置开始存放。*/  
        System.arraycopy(s, index+1, s, index, s.length-index-1);  
        // 下标s.length-1的值还是原来的值，我们要把它赋值为空，如果不这样做，运行会出现s[s.length-1]的值与s[s.length-2]的值一样  
        s[s.length-1] = null;  
        for(int i=0; i<s.length; i++){  
            System.out.println(i+"--"+s[i]);  
        }  
    }  
    public static void copyTest(){  
        int[] aa = {11,22,33,44,55,66};  
        int[] bb = new int[8];  
        // 从数组aa的下标2位置开始拷贝4个元素给bb数组，并从bb数组的下标3位置开始存放。  
        System.arraycopy(aa, 2, bb, 3, 4);  
        for(int i=0; i<bb.length; i++){  
            System.out.println(i+"--"+bb[i]);  
        }  
    }  
}
```

这里再增加一个插入

```java
int[] a = {11,22,33,44,55,66};  
int[] b = new int[a.length+1];  
System.out.println(b.length);  

System.arraycopy(a, 0, b, 0, a.length);  
System.out.println(Arrays.toString(b));  
System.out.println("==============================");  
System.arraycopy(b,3 ,b, 4, b.length-4);  
b[3] = 5;  
System.out.println(Arrays.toString(b));
```

效果：

![](/files/-LxV9ibg1WnHNzkZTr_2)

## Arrays工具类

主要方法是打印toString()，填充fill()，排序sort()，二分查找binarySearch()。

代码：

```java
package com.itcode.demo2;  

import java.util.Arrays;  

/** 
 * @author: 成都码到功成学员  
 * @Description:  
 *  Arrays工具类 
 */  

public class TestArray2 {  
    public static void main(String[] args) {  
        int[] a = {2,3544,454,323,2,3,234,23,43,231};  
        System.out.println("排序前："+ Arrays.toString(a));  
        Arrays.sort(a);  
        System.out.println("排序前："+ Arrays.toString(a));  
        System.out.println(Arrays.binarySearch(a, 23));// 返回23的下标  
        Arrays.fill(a,2,4, 888);  
        System.out.println("填充后  ："+ Arrays.toString(a));  
    }  
}
```

效果：

![](/files/-LxV9wOI9hilBI2lEREd)

#### 引用类型排序需实现Comparable接口。

实例：

```java
package com.itcode.demo2;  

import java.util.Arrays;  

/** 
 * @author: 成都码到功成学员  
 * @Description:  
 *  引用类型排序 
 *  Comparable<ArrayTest3>里面的ArrayTest3是泛型。 
 */  
class ArrayTest3 implements Comparable<ArrayTest3>{  

    String name;  
    int age;  
    public ArrayTest3(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
    @Override  
    public String toString() {  
        return "ArrayTest3{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                '}';  
    }  
    @Override  
    public int compareTo(ArrayTest3 o) {  
        // 按年龄比较  
        if(this.age>o.age){  
            return 1;  
        }  
        return 0;  
    }  
}  
public class TestArray3 {  
    public static void main(String[] args) {  
        ArrayTest3[] o = {  
                new ArrayTest3("成都", 3),  
                new ArrayTest3("北京", 5),  
                new ArrayTest3("上海", 2),  
                new ArrayTest3("深圳", 4)};  
        Arrays.sort(o);  
        System.out.println(Arrays.toString(o));  
    }  
}
```

效果：

![](/files/-LxVA3O5xPOcbTTV0C-X)

## 二维数组

多维数组中，一般最多用到二维数组。工作中很少用到数组，都是用容器，所以这一节了解即可。

二维数组的内存空间

比如我们定义一个二维数组：int\[]\[] a = new int\[3][2](https://app.gitbook.com/s/-LfnT30K7z1iNbyIaGVh/javaji-chu/shu-zu/代表创建三个长度为2的一维数组)。创建一个总的对象，有三个值a\[0]\[…]、a\[1]\[…]、a\[2]\[…]，然后这三个变量的值分别引用一维数组对象的地址值。

![](/files/-LxVACGdlRS_joZg5bnh)

实例：

```java
package com.itcode.demo2;  

import java.util.Arrays;  

/** 
 * @author: 成都码到功成学员  
 * @Description:  
 *  引用类型排序 
 *  Comparable<ArrayTest3>里面的ArrayTest3是泛型。 
 */  

public class TestArray4 {  
    public static void main(String[] args) {  
        // 二维数组静态初始化。  
        int[][] a = {  
                {2,3,4},  
                {2,1,2,3,45,56,4},  
                {2,34,4}  
        };  
        // 二维数组动态初始化。  
        int[][] b = new int[2][0];  

        // 数组测试  注意：这儿20170210并不是基本类，java编译器会把基本类包装成引用类型。  
        Object[][] o = new Object[4][];  
        o[0] = new Object[]{3, "张亮", "java", 20170210};  
        o[1] = new Object[]{6, "王集", "Android", 20180210};  
        o[2] = new Object[]{1, "陈丽", "UI", 20170310};  
        o[3] = new Object[]{4, "周动", "IOS", 20160210};  
        for(int i=0; i<o.length; i++){  
            System.out.println(Arrays.toString(o[i]));  
        }  
    }  
}
```

效果：

![](/files/-LxVAJXqRffbXy2vZTH9)

## 数组高级操作

### 冒泡排序

两两比较大小，大的往后，小的放前，交换位置。第一次循环比较完毕，最大的出现在最后面；第二次循环比较完毕，第二大的出现在最后面；依次类推，到最后一次比较完毕，从小到大依次排序。假如一个数组有N个元素，冒泡排序最多要比较1+2+3+……+n-1次，也就是(n-2)(n-1)/2次（请看初中数学）判断交换才把一组数字完全无误的比较从大到小出来。

代码：

```java
public static void main(String[] args) {  
        int[] aa = {7,34,23,45,1,46,34,2,6,3,9,8,5};  
        TestArray5.bubbleSort(aa);  
    }  
    public static void bubbleSort(int[] arr){  
        // 外循环  
        for(int a=1;a<arr.length+1;a++){  
            System.out.println("第" + a + "次循环");  
            // 内循环  
            for(int b=0; b<arr.length-a; b++) {  
                // 两个整数交换  
                if (arr[b] > arr[b + 1]) {  
                    int temp = arr[b];  
                    arr[b] = arr[b + 1];  
                    arr[b + 1] = temp;  
                }  
                System.out.println(Arrays.toString(arr));  
            }  
            System.out.println("第" + a + "次循环比较的最终结果："+Arrays.toString(arr));  
        }  
    }
```

结果：

```
第1次循环  

[7, 34, 23, 45, 1, 46, 34, 2, 6, 3, 9, 8, 5]  
[7, 23, 34, 45, 1, 46, 34, 2, 6, 3, 9, 8, 5]  
[7, 23, 34, 45, 1, 46, 34, 2, 6, 3, 9, 8, 5]  
[7, 23, 34, 1, 45, 46, 34, 2, 6, 3, 9, 8, 5]  
[7, 23, 34, 1, 45, 46, 34, 2, 6, 3, 9, 8, 5]  
[7, 23, 34, 1, 45, 34, 46, 2, 6, 3, 9, 8, 5]  
[7, 23, 34, 1, 45, 34, 2, 46, 6, 3, 9, 8, 5]  
[7, 23, 34, 1, 45, 34, 2, 6, 46, 3, 9, 8, 5]  
[7, 23, 34, 1, 45, 34, 2, 6, 3, 46, 9, 8, 5]  
[7, 23, 34, 1, 45, 34, 2, 6, 3, 9, 46, 8, 5]  
[7, 23, 34, 1, 45, 34, 2, 6, 3, 9, 8, 46, 5]  
[7, 23, 34, 1, 45, 34, 2, 6, 3, 9, 8, 5, 46]  
第1次循环比较的最终结果：[7, 23, 34, 1, 45, 34, 2, 6, 3, 9, 8, 5, 46]  
第2次循环  
[7, 23, 34, 1, 45, 34, 2, 6, 3, 9, 8, 5, 46]  
[7, 23, 34, 1, 45, 34, 2, 6, 3, 9, 8, 5, 46]  
[7, 23, 1, 34, 45, 34, 2, 6, 3, 9, 8, 5, 46]  
[7, 23, 1, 34, 45, 34, 2, 6, 3, 9, 8, 5, 46]  
[7, 23, 1, 34, 34, 45, 2, 6, 3, 9, 8, 5, 46]  
[7, 23, 1, 34, 34, 2, 45, 6, 3, 9, 8, 5, 46]  
[7, 23, 1, 34, 34, 2, 6, 45, 3, 9, 8, 5, 46]  
[7, 23, 1, 34, 34, 2, 6, 3, 45, 9, 8, 5, 46]  
[7, 23, 1, 34, 34, 2, 6, 3, 9, 45, 8, 5, 46]  
[7, 23, 1, 34, 34, 2, 6, 3, 9, 8, 45, 5, 46]  
[7, 23, 1, 34, 34, 2, 6, 3, 9, 8, 5, 45, 46]  
第2次循环比较的最终结果：[7, 23, 1, 34, 34, 2, 6, 3, 9, 8, 5, 45, 46]  
第3次循环  
[7, 23, 1, 34, 34, 2, 6, 3, 9, 8, 5, 45, 46]  
[7, 1, 23, 34, 34, 2, 6, 3, 9, 8, 5, 45, 46]  
[7, 1, 23, 34, 34, 2, 6, 3, 9, 8, 5, 45, 46]  
[7, 1, 23, 34, 34, 2, 6, 3, 9, 8, 5, 45, 46]  
[7, 1, 23, 34, 2, 34, 6, 3, 9, 8, 5, 45, 46]  
[7, 1, 23, 34, 2, 6, 34, 3, 9, 8, 5, 45, 46]  
[7, 1, 23, 34, 2, 6, 3, 34, 9, 8, 5, 45, 46]  
[7, 1, 23, 34, 2, 6, 3, 9, 34, 8, 5, 45, 46]  
[7, 1, 23, 34, 2, 6, 3, 9, 8, 34, 5, 45, 46]  
[7, 1, 23, 34, 2, 6, 3, 9, 8, 5, 34, 45, 46]  
第3次循环比较的最终结果：[7, 1, 23, 34, 2, 6, 3, 9, 8, 5, 34, 45, 46]  
第4次循环  
[1, 7, 23, 34, 2, 6, 3, 9, 8, 5, 34, 45, 46]  
[1, 7, 23, 34, 2, 6, 3, 9, 8, 5, 34, 45, 46]  
[1, 7, 23, 34, 2, 6, 3, 9, 8, 5, 34, 45, 46]  
[1, 7, 23, 2, 34, 6, 3, 9, 8, 5, 34, 45, 46]  
[1, 7, 23, 2, 6, 34, 3, 9, 8, 5, 34, 45, 46]  
[1, 7, 23, 2, 6, 3, 34, 9, 8, 5, 34, 45, 46]  
[1, 7, 23, 2, 6, 3, 9, 34, 8, 5, 34, 45, 46]  
[1, 7, 23, 2, 6, 3, 9, 8, 34, 5, 34, 45, 46]  
[1, 7, 23, 2, 6, 3, 9, 8, 5, 34, 34, 45, 46]  
第4次循环比较的最终结果：[1, 7, 23, 2, 6, 3, 9, 8, 5, 34, 34, 45, 46]  
第5次循环  
[1, 7, 23, 2, 6, 3, 9, 8, 5, 34, 34, 45, 46]  
[1, 7, 23, 2, 6, 3, 9, 8, 5, 34, 34, 45, 46]  
[1, 7, 2, 23, 6, 3, 9, 8, 5, 34, 34, 45, 46]  
[1, 7, 2, 6, 23, 3, 9, 8, 5, 34, 34, 45, 46]  
[1, 7, 2, 6, 3, 23, 9, 8, 5, 34, 34, 45, 46]  
[1, 7, 2, 6, 3, 9, 23, 8, 5, 34, 34, 45, 46]  
[1, 7, 2, 6, 3, 9, 8, 23, 5, 34, 34, 45, 46]  
[1, 7, 2, 6, 3, 9, 8, 5, 23, 34, 34, 45, 46]  
第5次循环比较的最终结果：[1, 7, 2, 6, 3, 9, 8, 5, 23, 34, 34, 45, 46]  
第6次循环  
[1, 7, 2, 6, 3, 9, 8, 5, 23, 34, 34, 45, 46]  
[1, 2, 7, 6, 3, 9, 8, 5, 23, 34, 34, 45, 46]  
[1, 2, 6, 7, 3, 9, 8, 5, 23, 34, 34, 45, 46]  
[1, 2, 6, 3, 7, 9, 8, 5, 23, 34, 34, 45, 46]  
[1, 2, 6, 3, 7, 9, 8, 5, 23, 34, 34, 45, 46]  
[1, 2, 6, 3, 7, 8, 9, 5, 23, 34, 34, 45, 46]  
[1, 2, 6, 3, 7, 8, 5, 9, 23, 34, 34, 45, 46]  
第6次循环比较的最终结果：[1, 2, 6, 3, 7, 8, 5, 9, 23, 34, 34, 45, 46]  
第7次循环  
[1, 2, 6, 3, 7, 8, 5, 9, 23, 34, 34, 45, 46]  
[1, 2, 6, 3, 7, 8, 5, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 7, 8, 5, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 7, 8, 5, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 7, 8, 5, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 7, 5, 8, 9, 23, 34, 34, 45, 46]  
第7次循环比较的最终结果：[1, 2, 3, 6, 7, 5, 8, 9, 23, 34, 34, 45, 46]  
第8次循环  
[1, 2, 3, 6, 7, 5, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 7, 5, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 7, 5, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 7, 5, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 5, 7, 8, 9, 23, 34, 34, 45, 46]  
第8次循环比较的最终结果：[1, 2, 3, 6, 5, 7, 8, 9, 23, 34, 34, 45, 46]  
第9次循环  
[1, 2, 3, 6, 5, 7, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 5, 7, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 6, 5, 7, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
第9次循环比较的最终结果：[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
第10次循环  
[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
第10次循环比较的最终结果：[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
第11次循环  
[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
第11次循环比较的最终结果：[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
第12次循环  
[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
第12次循环比较的最终结果：[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]  
第13次循环  
第13次循环比较的最终结果：[1, 2, 3, 5, 6, 7, 8, 9, 23, 34, 34, 45, 46]
```

看结果是不是有13个数字第一次循环比较了12次，第二次循环比较了11次，……第12次就比较了一次，总共比较了156次。

之前我们说过是一个拥有N个元素的数组最多需要(n-1)n次可以循环处理结果。然后注意再看结果

![](/files/-LxVAikfJqohy4FGO8Qu)

在第9次循环的最后一次比较排序结果就已经完全出来了。

所以我们要做优化

```java
public static void bubbleSort(int[] arr){  
        // 外循环  
        for(int a=1;a<arr.length+1;a++){  
            boolean flag = true;  
            System.out.println("第" + a + "次循环");  
            // 内循环  
            for(int b=0; b<arr.length-a; b++) {  
                // 两个整数交换  
                if (arr[b] > arr[b + 1]) {  
                    int temp = arr[b];  
                    arr[b] = arr[b + 1];  
                    arr[b + 1] = temp;  
                    // 如果发生了交换，flag就变为false  
                    flag = false;  
                }  
                System.out.println(Arrays.toString(arr));  
            }  
            // 如果没有发生位置交换，证明数组已经排序完毕，跳出循环。  
            if(flag){  
                break;  
            }  
            System.out.println("第" + a + "次循环比较的最终结果："+Arrays.toString(arr));  
        }  
    }
```

效果：

![](/files/-LxVAqgeIOAC6Zpm6x0Z)

完整代码：

```java
package com.itcode.demo2;  

import java.util.Arrays;  

/** 
 * @author: 成都码到功成学员  
 * @Description:  
 *  冒泡排序 
 */  

public class TestArray5 {  
    public static void main(String[] args) {  
        int[] aa = {7,34,23,45,1,46,34,2,6,3,9,8,5};  
        TestArray5.bubbleSort1(aa);  
    }  
    // 正式面试这样写即可  
    public static void bubbleSort1(int[] arr){  
        for(int a=0; a<arr.length-1; a++){  
            boolean flag = true;  
            for (int b=0;b<arr.length-a-1; b++){  
//              if(arr[b+1] < arr[b]){// 升序排序  
                if(arr[b] < arr[b+1]){// 降序排序  
                    int temp = arr[b];  
                    arr[b] = arr[b+1];  
                    arr[b+1] = temp;  
                    flag = false;  
                }  
            }  
        }  
        System.out.println(Arrays.toString(arr));  
    }  
    // 这个方法主要是为了让大家看懂，所以多打印一些东西  
    public static void bubbleSort(int[] arr){  
        // 外循环  
        for(int a=1;a<arr.length+1;a++){  
            boolean flag = true;  
            System.out.println("第" + a + "次循环");  
            // 内循环  
            for(int b=0; b<arr.length-a; b++) {  
                // 两个整数交换  
                if (arr[b] > arr[b + 1]) {  
                    int temp = arr[b];  
                    arr[b] = arr[b + 1];  
                    arr[b + 1] = temp;  
                    // 如果发生了交换，flag就变为false  
                    flag = false;  
                }  
                System.out.println(Arrays.toString(arr));  
            }  
            // 如果没有发生位置交换，证明数组已经排序完毕，跳出循环。  
            if(flag){  
                break;  
            }  
            System.out.println("第" + a + "次循环比较的最终结果："+Arrays.toString(arr));  
        }  
    }  
}
```

### 选择排序

概述：第一次排序会把后面的每一个元素和第一个元素比较，如果比第一个元素小，就把交换位置，第一次比较完毕，最小的值出现在第一位。接下来又是第二个元素和后面的元素一一比较…比较完毕，第二小的值出现在第二位。以此类推，到最后一位比较完毕，得到一个升序数组。数组长度是几就比较几次。

如：数组 int\[] arr={5,2,8,4,9,1};下面是五次比较结果

```
1  2  8  4  9  5
1  2  8  4  9  5
1  2  4  8  9  5
1  2  4  5  9  8
1  2  4  5  8  9
```

示例：

```
// 选择排序  
public static void test10(){  
    int[] a = {36,43,74,24,27};  
    for(int i=0;i<a.length-1;i++){  
        for(int j=i+1;j<a.length;j++){  
            //if(a[j]<a[i]){//升序  
            if(a[j]>a[i]){//降序  
                int t = a[j];  
                a[j] = a[i];  
                a[i] = t;  
            }  
        }  
    }  
    System.out.println(Arrays.toString(a));  
}
```

### 二分查找

前提：排序好

概括：把一个数字从升序排序好的一组数字之间最中间那个数进行比较，如果等于，之间返回此数字下标；如果大于，就从这个中间数字的后一位和最后一位的中间位置再进行比较；

如果小于，就从这个中间数字的前一位和最前一位的中间位置再进行比较。如此反复，直到找完为止，找到返回，没有找到符合的值，报错。

实例：

```java
package com.itcode.demo2;  

import java.util.Arrays;  

/** 
 * @author: 成都码到功成学员  
 * @Description:  
 *  二分查找 
 */  

public class TestArray6 {  
    public static void main(String[] args) {  
        int[] aa = {7,34,23,45,1,46,2,6,3,9,8,5};  
        Arrays.sort(aa);  
        System.out.println(Arrays.toString(aa));  
        System.out.println(TestArray6.binarySearch(aa, 5));  
    }  
    // arr数组，a要查的值  
    public static int binarySearch(int[] arr, int a){  
        int start = 0;  
        int end = arr.length-1;  
        while (start <= end){  
            int mid = (start+end)/2;  
            if(a == arr[mid]){  
                return mid;  
            }  
            if(a < arr[mid]){  
                end = mid - 1;  
            }  
            if(a > arr[mid]){  
                start = mid + 1;  
            }  
        }  
        return -1;  
    }  
}
```

### 杨辉三角

效果：

![](/files/-LxVBHtx3EUcDQn89lsg)

代码：

```java
// 杨辉三角  
public static void test11(){  
    // 设定外层值 10  
    int[][] a = new int[10][];  
    for(int i=0;i<a.length;i++){  
        //为一维数组分配空间  
        a[i] = new int[i+1];  
        for(int j=0;j<a[i].length;j++){  
            // 打印两边外层1  
            if(j==0 || j== a[i].length-1){  
                a[i][j] = 1;  
                System.out.print(a[i][j] + "\t");  
            }else {  
                // 打印中心值  
                a[i][j] = a[i-1][j-1]+a[i-1][j];  
                System.out.print(a[i][j]+"\t");  
            }  
        }  
        // 换行  
        System.out.println();  
    }  
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://xiaoxiami.gitbook.io/java/javaji-chu/shu-zu/shu-zu-jin-jie.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.