001数组

最新推荐文章于 2024-09-13 17:30:19 发布

做一个有信仰de人

最新推荐文章于 2024-09-13 17:30:19 发布

阅读量376

点赞数

分类专栏： java② 文章标签： java

本文链接：https://blog.csdn.net/z1475307570/article/details/105473731

版权

java② 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、一维数组

1. 写出一维数组的声明与初始化

int[] ids ;
//1.静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1,2,3,4,5} ;
//2.动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] strs = new String[5] ;

int[] arr4 = {1,2,3,4,5} ;//类型推断

2.数组的调用

//数组的角标（或索引从0开始的，带数组长度array.length-1结束）
names[0]= "Tom" ;
names[1]= "Jack" ;
names[2]= "Anna" ;//charAt(index)

3.如何获得数组的长度？

array.lenth（length是数组中的一个属性）

4.一维数组的遍历

for(int j=0; j<array.length; j++){
    System.out.print(array[j] + ",") ;
}

5、一维数组元素的默认初始化值

整型：0
浮点型：0.0
char：0或'/u0000',不是'0'
boolean：false
引用类型：null

6、一维数组内存解析

二、二维数组

1.二维数组的的声明与初始化

//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9}};
//动态初始化1
int[][] arr2 = new int[3][2] ;
//动态初初始化2
int[][] arr2 = new int[3][] ;

2.二维数组的调用

int[][] arr2 = new int[3][4] ;

arr2[0][1] = 123 ；
arr2[1] = new int[4] ;

arr2[2]//打印会输出地址值

3.获得二维数组的长度？

int[][] arr2 = new int[3][4] ;

//外层长度：3
arr2.length
//内层长度：4
arr2[0].length

4.二维数组的遍历

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先赋值，之后第i行j列等于第i-1行j-1列加是第i-1行j列

public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("请输入要打印的杨辉三角行数:");
            //从键盘获取要打印的杨辉三角行数
            String temp = sc.nextLine();
            try {
                //将键盘输入字符串转化为int类型，如果格式不正确，则提示输入格式不正确
                int rowsNum = Integer.parseInt(temp);
                getPascalTriangle(rowsNum);
            } catch (Exception e) {
                //e.printStackTrace();
                System.out.println("输入的格式不正确，请输入数字:");
            }
        }
    }
 
    //获取杨辉三角的二维数组
    private static void getPascalTriangle(int rowsNum) {
        int n = rowsNum;
        //构建二维数组
        int[][] ss = new int[n][];
        //给每行第一个和最后一个赋值为1
        for (int i = 0; i < ss.length; i++) {
            ss[i]=new int[i+1];
            ss[i][0]=1;
            ss[i][i]=1;
        }
        //给每行其他列赋值
        for (int i = 2; i < ss.length; i++) {
            for (int j = 1; j < ss[i].length-1; j++) {
                ss[i][j]=ss[i-1][j-1]+ss[i-1][j];
            }
        }
        //遍历打印杨辉三角
        printArray(ss);
        
    }
 
    //遍历方法
    private static void printArray(int[][] ss) {
        for (int i = 0; i < ss.length; i++) {
            for (int j = 0; j < ss[i].length; j++) {
                System.out.print(ss[i][j]+" ");
            }
            System.out.println();
        }
    }
}

源文链接：java实现杨辉三角

2. 回形数格式方阵的实现

主要思路：分别通过数组长度和数组是否赋值判断是否转向

public class HuiXing {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int vol = 15;//矩阵阶数
        
        int[][] arr = new int[vol][vol];
        
        int x = 0;
        int y = 0;//初始坐标
        int num = 1;
        
        while(arr[x][y] != (vol * vol)) {
            arr[x][y] = num;
            
            if(y != vol - 1 && arr[x][y + 1] == 0) {//→
                if(x > 0 && arr[x - 1][y]==0) {//优先向↑走
                    x--;
                }else {
                    y++;
                }
            }else if(x != vol - 1 && arr[x + 1][y] == 0) {//↓
                x++;
            }else if(y != 0 && arr[x][y - 1] == 0) {//←
                y--;
            }else if(arr[x - 1][y] == 0){//↑
                x--;
            }
            
            num++;
        }
        
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

原文链接：Java回形数问题

3. 求数值型数组中元素最大值、最小值、平均值、总和等

要求：定义一个int型数组的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，总和，平均值，并输出来。所有的随机数数都是两位

tip:[a,b]公式:(int)(Math.random() * (b-a+1) + a)

public class Arraytest1 {
    public static void main(String[] args) {
        int[] arr = new int[10] ;
        
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * (99-10+1) + 10) ;
        }
        
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + "\t");
        }
        System.out.println();
        
        //求数组元素的最大值
        int maxValue = arr[0] ;
        for (int i = 0; i < arr.length; i++) {
            if (maxValue < arr[i]) {
                maxValue = arr[i] ;
            }
        }
        System.out.println("最大值为：" + maxValue);
        //求数组元素的最大值
        int minValue = arr[0] ;
        for (int i = 0; i < arr.length; i++) {
            if (minValue > arr[i]) {
                minValue = arr[i] ;
            }
        }
        System.out.println("最小值为：" + minValue);
        //求数组的总和
        int sumValue = 0 ;
        for (int i = 0; i < arr.length; i++) {
            sumValue += arr[i] ;
        }
        System.out.println("总和为：" + sumValue);
        //求数组的平均值
        int avgValue = sumValue / arr.length ;
        System.out.println("平均值为：" + avgValue);
    }
}

4. 数组复制

使用简单的数组
(1)创建一个类，在mina()方法array1和arrays2两个变量，他们是int[]类型的数组
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19
(3)显示array1的内容
(4)赋值array2变等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0),打印array1

public class ArrayTest2 {
    public static void main(String[] args) {
        int[] array1, array2 ;
        
        array1 = new int[]{2,3,5,7,11,13,17,19} ;
        
        //显示array1的内容
        for(int i=0; i<array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        System.out.println();
        
        //赋值array2变等于array1
        //不能称作数组的复制
        array2 = array1 ;
        
        //修改array2中的偶索引元素，使其等于索引值(如array[0]=0)
        for(int i=0; i<array2.length; i++) {
            if(i%2 == 0) {
                array2[i] = i ;
            }
        }
        //显示array1的内容
        for(int i=0; i<array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        System.out.println();
    }
}

思考：array1与array2是什么关系

array1与array2地址值相同，都指向了对空间的位置的一个数组实体

拓展：修改题目，实现array2对array1的复制

array2 = new int[array1.length] ;
for(int i=0; i<array2.length; i++) {
    array2[i] = array1[i] ;
}

5. 数组的复制、反转、查找(线性查找、二分法查找)

public class ArrayTest3 {
    public static void main(String[] args) {
        String[] str = new String[] {"AA", "BB", "CC", "DD", "EE", "FF"} ;
        
        //数组的复制
        String[] str1 = new String[str.length] ;
        for(int i=0; i<str1.length; i++) {
            str1[i] = str[i] ;
        }
        //数组的反转
        //方法一
        for(int i=0; i<str.length/2; i++) {
            String temp = str[i] ;
            str[i] = str[str.length-1 -i] ;
            str[str.length-i] = temp ;
        }
        //方法二
        for(int i=0, j=str.length-1; i<j; i++,j--) {
            String temp = str[i] ;
            str[i] = str[j] ;
            str[j] = temp ;
        }
        
        //查找
        //线性查找：
        String target = "EE" ;
        int index = -1 ;
        for(int i=0; i<str.length; i++) {
            if(target.equals(str[i])) {
                index = i ;
                System.out.println("找到指定元素，位置为" + i);
                break ;
            }
        }
        if(index == -1) {
            System.out.println("遗憾，没有找到");
        }
        
        //二分法查找
        //前提：所要查找的数组必须有序
        int[] array1 = new int[] {1,2,14,15,77} ;
        int t = 77 ;
        int head = 0 ;
        int end = str.length-1 ;
        boolean isFlag = true ;
        while (head <= end) {
            int middle = (head + end) / 2 ;
            
            if(array1[middle] == t) {
                isFlag = false ;
                System.out.println("找到指定元素，位置为" + middle);
                break ;
            } else if(array1[middle] > t) {
                end = middle-1 ;
            } else if(array1[middle] < t) {
                head = middle+1 ;
            }
        }
        if(isFlag) {
            System.out.println("遗憾，没有找到");
        }
        
    }
}

4. Arrays常用方法

序号	方法	描述
1	boolean equals(int[] a, int[] b)	判断两数组是否相等
2	String toString(int[] a)	输出数组信息
3	void fill(int[] a, int val)	将指定值填充到数组之中
4	void sort(int[] a)	将数组进行排序
5	int binarySearch(int[] a, int key)	对排序后的数组进行二分法检索指定的值