关于java:Java数组排序和查找

数组介绍

数组能够寄存多个同一类型的数据。数组也是一种数据类型，是援用类型。

数组的应用

应用形式 1 - 动静初始化数组的定义

数据类型数组名 []=new 数据类型 [ 大小]

int a[] = new int[5];// 创立了一个数组，名字 a, 寄存 5 个 int

阐明: 这是定义数组的一种办法。

import java.util.Scanner;
public class Array02 { 

    // 编写一个 main 办法
    public static void main(String[] args) {// 演示 数据类型 数组名 []=new 数据类型 [大小]
        // 循环输出 5 个问题，保留到 double 数组, 并输入

        // 步骤
        //1. 创立一个 double 数组，大小 5

        //(1) 第一种动态分配形式
        //double scores[] = new double[5];
        //(2) 第 2 种动态分配形式，先申明数组，再 new 调配空间
        double scores[] ; // 申明数组，这时 scores 是 null
        scores = new double[5]; // 分配内存空间，能够存放数据


        //2. 循环输出
        //   scores.length 示意数组的大小 / 长度
        //   
        Scanner myScanner = new Scanner(System.in);
        for(int i = 0; i < scores.length; i++) {System.out.println("请输出第"+ (i+1) +"个元素的值");
            scores[i] = myScanner.nextDouble();}

        // 输入，遍历数组
        System.out.println("== 数组的元素 / 值的状况如下:===");
        for(int i = 0; i < scores.length; i++) {System.out.println("第"+ (i+1) +"个元素的值 =" + scores[i]);
        }
    }
}

应用形式 2 - 动静初始化

1. 先申明数组

语法: 数据类型数组名 []; 也能够数据类型 [] 数组名;

int a[]; 或者 int[] a;

2. 创立数组

语法: 数组名 =new 数据类型 [大小];

a=new int[10];

应用形式 3 - 动态初始化

初始化数组

语法:

数据类型 数组名 []={ 元素值，元素值 …}

int a[]={2,5,6,7,8,89,90,34,56},

数组应用注意事项和细节

1. 数组中的元素能够是任何数据类型，包含根本类型和援用类型，然而不能混用。
2. 数组创立后，如果没有赋值，有默认值
   int 0

short 0

byte 0

long 0

float 0.0

double 0.0

char \u0000

boolean false

String null

3. 数组属援用类型，数组型数据是对象 (object)

数组利用案例

创立一个 char 类型的 26 个元素的数组，别离搁置 ’A’-‘Z’。应用 for 循环拜访所有元素并打印进去。提醒：char 类型数据运算 ’A’+2 -> ‘C’

public class ArrayExercise01 { 

    // 编写一个 main 办法
    public static void main(String[] args) {

        /*
        创立一个 char 类型的 26 个元素的数组，别离 搁置 'A'-'Z'。应用 for 循环拜访所有元素并打印进去。提醒：char 类型数据运算 'A'+1 -> 'B'  

        思路剖析
        1. 定义一个 数组  char[] chars = new char[26]
        2. 因为 'A' + 1 = 'B' 类推，所以老师应用 for 来赋值
        3. 应用 for 循环拜访所有元素
         */
        char[] chars = new char[26];
        for(int i = 0; i < chars.length; i++) {// 循环 26 次
            //chars 是 char[] 
            //chars[i] 是 char
            chars[i] = (char)('A' + i); //'A' + i 是 int , 须要强制转换
        }

        // 循环输入
        System.out.println("===chars 数组 ===");
        for(int i = 0; i < chars.length; i++) {// 循环 26 次
            System.out.print(chars[i] + " ");
        }

    }
}

数组赋值机制

数组在默认状况下是援用传递，赋的值是地址。(相比：变量往往是值传递)

int[] arr1 = {1,2,3};
int[] arr2 = arr1;

数组拷贝

编写代码实现数组拷贝 (内容复制)

int[] arr1 = {10,20,30};
int[] arr2 = new int[arr1.length];
for(int i = 0; i < arr1.length; i++) {arr2[i] = arr1[i];
}

数组增加 / 扩容

要求：实现动静的给数组增加元素成果，实现对数组扩容。

1. 原始数组应用动态调配 int[] arr = {1,2,3}
2. 减少的元素 4，间接放在数组的最初 arr = {1,2,3,4}
3. 用户能够通过如下办法来决定是否持续增加，增加胜利，是否持续？y/n

1. 定义初始数组 int[] arr = {1,2,3}// 下标 0 -2
2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
3. 遍历 arr 数组，顺次将 arr 的元素拷贝到 arrNew 数组
4. 将 4 赋给 arrNew[arrNew.length - 1] = 4; 把 4 赋给 arrNew 最初一个元素
5. 让 arr 指向 arrNew ; arr = arrNew; 那么原来 arr 数组就被销毁
6. 创立一个 Scanner 能够承受用户输出
7. 因为用户什么时候退出，不确定，应用 do-while + break 来管制 

多维数组 二维数组

动静初始化 1

1. 语法: 类型 [][] 数组名 =new 类型 [大小][大小]
2. 比方: int a[][]=new int[2][3]
3. 二维数组在内存的存在模式 (!! 画图)

动静初始化 2

先申明：类型数组名 [][];

再定义 (开拓空间) 数组名 = new 类型 [大小][大小]

赋值 (有默认值，比方 int 类型的就是 0)

动态初始化

定义类型数组名 [][] = {{值 1, 值 2..},{值 1, 值 2..},{值 1, 值 2..}}
int[][] arr = {{1,1,1}, {8,8,9}, {100}};

二维数组的利用案例

应用二维数组打印一个 10 行杨辉三角

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

1. 第一行有 1 个元素, 第 n 行有 n 个元素

2. 每一行的第一个元素和最初一个元素都是 1

3. 从第三行开始, 对于非第一个元素和最初一个元素的元素的值.

arr[i][j] = arr[i-1][j] + arr[i-1][j-1];

public class YangHui { 

    // 编写一个 main 办法
    public static void main(String[] args) {
        /*
        应用二维数组打印一个 10 行杨辉三角
        1
        1 1
        1 2 1
        1 3 3  1
        1 4 6  4  1
        1 5 10 10 5 1

        法则
         1. 第一行有 1 个元素, 第 n 行有 n 个元素
         2. 每一行的第一个元素和最初一个元素都是 1
         3. 从第三行开始, 对于非第一个元素和最初一个元素的元素的值. arr[i][j] 
          arr[i][j]  =  arr[i-1][j] + arr[i-1][j-1]; // 必须找到这个法则

         */
        int[][] yangHui = new int[12][];
        for(int i = 0; i < yangHui.length; i++) {// 遍历 yangHui 的每个元素

            // 给每个一维数组 (行) 开空间
            yangHui[i] = new int[i+1];
            // 给每个一维数组 (行) 赋值
            for(int j = 0; j < yangHui[i].length; j++){
                // 每一行的第一个元素和最初一个元素都是 1
                if(j == 0 || j == yangHui[i].length - 1) {yangHui[i][j] = 1;
                } else {// 两头的元素
                    yangHui[i][j]  =  yangHui[i-1][j] + yangHui[i-1][j-1];
                }
            }
        }
        // 输入杨辉三角
        for(int i = 0; i < yangHui.length; i++) {for(int j = 0; j < yangHui[i].length; j++) {// 遍历输入该行
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();// 换行.}
    }
}

二维数组应用细节和注意事项

1. 一维数组的申明形式有:

int[] x 或者 int x[]

2. 二维数组的申明形式有:

int[][] y 或者 int[] y[] 或者 int y[][]

3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度能够雷同，也能够不雷同。比方：map[][] 是一个二维数组

int map [][] = {{1,2},{3,4,5}}

由 map[0] 是一个含有两个元素的一维数组，map[1] 是一个含有三个元素的一维数组形成，咱们也称为列数不等的二维数组

文章和代码曾经归档至【Github 仓库：https://github.com/timerring/java-tutorial】或者公众号【AIShareLab】回复 java 也可获取。