Java筑基07-数组&排序&查找

一、数组

什么是数组？

数组可以存放同一类型的数据，数组也是一种数据类型，是引用类型。即数组就是一组数据。

/**
 * @author: 程序员飞扬
 * @date: 2022-02-06
 * @description:
 */
public class ArrayTest01 {
    public static void main(String[] args) {
        double[] arr = {10,20.5,30.5};
        double total = 0;
        for (int i=0;i<arr.length;i++){
            System.out.println("第" + (i+1) + "个数为：" + arr[i]);
            total +=arr[i];
        }
        System.out.println("总和：" + total);
    }
}

输出：

第1个数为：10.0

第2个数为：20.5

第3个数为：30.5

总和：61.0

语法

使用方式一：动态初始化 int a[] = new int[5];

使用方式二：动态初始化 int a[]; a=new int[5];

使用方式三：静态初始化 int[] a = {10,20,30}

数组使用注意事项：

案例一：利用数组打印26个大写字母

/**
 * @author: 程序员飞扬
 * @date: 2022-02-06
 * @description:
 */
public class ArrayTest02 {
    public static void main(String[] args) {
        char[] chars = new char[26];
        for (int i = 0; i < chars.length; i++) {
            chars[i] = (char) ('A' + i);
            System.out.print(chars[i]+" ");
        }

    }
}

输出：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

案例二：求出数组的最大值及对应的坐标

/**
 * @author: 程序员飞扬
 * @date: 2022-02-06
 * @description:求出数组的最大值及对应的坐标
 */
public class ArrrayTest03 {
    public static void main(String[] args) {
        int[] arr = {6,-2,15,20,35};
        int max=arr[0];
        int maxIndex=0;
        for (int i = 1; i < arr.length; i++) {
            if(max<arr[i]){
                max = arr[i];
                maxIndex = i;
            }
        }
        System.out.println("max=" + max + ",maxIndex=" + maxIndex);
    }
}

输出：max=35,maxIndex=4

数组赋值机制

数组拷贝

/**
 * @author: 程序员飞扬
 * @date: 2022-02-06
 * @description:求
 */
public class ArrrayCopyTest01 {
    public static void main(String[] args) {
        int[] arr1 = {6,-2,15,20,35};
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }


        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+" ");
        }
    }
}

输出：6 -2 15 20 35

数组翻转

数组翻转，交换法：

/**
 * @author: 程序员飞扬
 * @date: 2022-02-06
 * @description:数组翻转，交换法
 */
public class ArrayExchangTest01 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        int temp=0;
        int len=arr.length;
        for (int i = 0; i < len/2; i++) {
            temp = arr[len-1-i];
            arr[len-1-i] = arr[i];
            arr[i] = temp;
        }

        for (int i = 0; i < len; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

输出：55 44 33 22 11

数组翻转,逆序赋值法：

/**
 * @author: 程序员飞扬
 * @date: 2022-02-06
 * @description:数组翻转,逆序赋值法
 */
public class ArrayExchangTest01 {
    public static void main(String[] args) {
        int[] arr1 = {11,22,33,44,55};
        int temp=0;
        int len=arr1.length;
        /*for (int i = 0; i < len/2; i++) {
            temp = arr[len-1-i];
            arr[len-1-i] = arr[i];
            arr[i] = temp;
        }

        for (int i = 0; i < len; i++) {
            System.out.print(arr[i] + " ");
        }*/

        int[] arr2 = new int[len];
        for (int i = 0; i < len; i++) {
            arr2[i] = arr1[len-1-i];
        }

        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }

    }
}

输出：55 44 33 22 11

数组扩容

/**
 * @author: 程序员飞扬
 * @date: 2022-02-06
 * @description:数组扩容
 */
public class ArrayDilatationTest01 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        int len=arr1.length;
        int[] arr2 = new int[len+1];
        for (int i = 0; i < len; i++) {
            arr2[i] = arr1[i];
        }
        arr2[len] = 4;

        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
    }
}

动态扩容：

/**
 * @author: 程序员飞扬
 * @date: 2022-02-06
 * @description:数组扩容：动态扩容
 */
public class ArrayDilatationTest02 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        Scanner scanner = new Scanner(System.in);
        do{
            int len=arr1.length;
            int[] arr2 = new int[len+1];
            for (int i = 0; i < len; i++)
            {
                arr2[i] = arr1[i];
            }
            System.out.println("请输入你要添加的元素：");
            int addNum = scanner.nextInt();
            arr2[len] = addNum;
            arr1 = arr2;
            for (int i = 0; i < arr1.length; i++) {
                System.out.print(arr1[i] + " ");
            }

            System.out.println();
            System.out.println("是否继续添加y/n");
            char c = scanner.next().charAt(0);
            if('n' == c){
                break;
            }
        }while(true);
        System.out.println("添加完毕，程序继续执行。。。");
    }
}

二、排序

排序介绍

冒泡排序

冒泡排序分析

代码演示：

/**
 * @author: 程序员飞扬
 * @description:冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {20,12,34,56,80};
        int temp = 0;//临时变量
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1 - i; j++) {
                if(arr[j]>arr[j+1]){
                    temp=arr[i];
                    arr[i]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

输出：12 20 34 56 80

三、查找

顺序查找：

/**
 * @author: 程序员飞扬
 * @description:顺序查找
 */
public class SeqSearch {

    public static void main(String[] args) {
        String[] arr={"11","22","33"};
        int i =-1;
        Scanner scanner = new Scanner(System.in);
        String inputName = scanner.next();
        for (int j = 0; j < arr.length; j++) {
            if(inputName.equals(arr[j])){
                System.out.println("你要找的值是第" + (j+1) + "个数");
                i = j;
                break;//退出循环
            }
        }
        if(i == -1){
            //说明没进入if条件
            System.out.println("抱歉，未找到");
        }
    }
}

输出：

33

你要找的值是第3个数

四、二位数组

使用方式1：静态初始化

/**
 * @author: 程序员飞扬
 * @description:二维数组
 */
public class TwoDimensionArray01 {

    public static void main(String[] args) {
        int[][] arr = {{1,2,3},
                {4,5,6},
                {7,8,9}};
        for (int i = 0; i < arr.length; i++) {//遍历二维数组的长度
            for (int j = 0; j < arr[i].length; j++) {//对每个一维数组遍历
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

输出：

1 2 3

4 5 6

7 8 9

使用方式2：动态初始化

/**
 * @author: 程序员飞扬
 * @description:二维数组动态生成
 */
public class TwoDimensionArray02 {

    public static void main(String[] args) {
        int[][] arr = new int[2][3];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

输出：

0 0 0

0 0 0

内存分析

使用方式3：动态初始化-列数不确定

/**
 * @author: 程序员飞扬
 * @description:二维数组动态生成
 */
public class TwoDimensionArray03 {

    public static void main(String[] args) {
        int[][] arr = new int[10][];//创建二维数组，但是只确定一维数组的个数，具体一维数组长度不确定
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i + 1];//给每一个一维数组开辟空间
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = i+1;//赋值
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

输出：

1

2 2

3 3 3

4 4 4 4

5 5 5 5 5

6 6 6 6 6 6

7 7 7 7 7 7 7

8 8 8 8 8 8 8 8

9 9 9 9 9 9 9 9 9

10 10 10 10 10 10 10 10 10 10

练习一：杨辉三角

/**
 * @author: 程序员飞扬
 * @description:杨辉三角
 */
public class YangHuiArrayTest {

    public static void main(String[] args) {
        /**
         *
         *1
         *1 1
         *1 2 1
         *1 3 3 1
         *1 4 6 4 1
         *
         */
        int[][] arr = new int[10][];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i + 1];
            for (int j = 0; j < arr[i].length; j++) {
                if(j==0 || j==arr[i].length-1){
                    arr[i][j] = 1;
                }else{
                    arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

输出：

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

1 6 15 20 15 6 1

1 7 21 35 35 21 7 1

1 8 28 56 70 56 28 8 1

1 9 36 84 126 126 84 36 9 1

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