JAVA数组

概述
- 相同类型的元素集合，一旦创建就不可改变
- 数组变量属于引用类型(.a),数组本身就是一个对象，Java中的对象在堆中
- 可以是任何数据，基本类型，引用类型

数组声明创建

public class A {

变量的类型名字

dateType[] arrayF  //首选方法，变量类型之后加[]号
dateType arrayF[]  //意义相同一般不选，c跟c++中常用

dateType[] arrayF=new dateType[arrayS--具体数值]  //创建数组
    
int[] n;                                         //声明一个数组
n=new int[3];                                    //新定义10个不同的数
n[0]=20;
n[1]=30;
n[2]=90;
System.out.println(n[1]);

30
    
public static void main(String[] args) {
int[] n=new int[3];
n[0]=20;
n[1]=30;
n[2]=90;
int sum = 0;
for (int i = 0; i < n.length; i++) {
    sum+=n[i];
    }
    System.out.println(sum);
}
        
140

    
int[] n=new int[3];                              //跟n=new int[3]; 相似，声明和创建一块做

数组使用

静态初始化：
    int[] n={1,2,3,4}
    Man[] mans = {new Man(),Man()}
动态初始化：
    int[] n=new int[2];
    a[0]=10;
    a[1]=20;

输出和

public static void main(String[]args){
    int[] a={1,2,3,4,5};
    System.out.println(a[2]);
    int sum=0;
    for (int i = 0; i < a.length; i++) {
        sum+=a[i];
    }
    System.out.println(sum);             // 注意位置不要放错，不能放到for循环内部
}

3
15

查找最大元素

        public static void main(String[]args){
        int[] a={1,2,3,4,5};
        int max=a[0];
        for (int i = 0; i < a.length; i++) {
            if (max<a[i]){
                max=a[i];
            }
        }
        System.out.println(max);
            
5
    
        public static void main(String[]args){
        int[] a={1,2,3,4,5};
        for (int i :a) {
            System.out.print(i);
        }
            
12345

将元素进行倒置**

    public static void main(String[]args){
        int[] a={1,2,3,4,5};
        int[] re=re(a);
        printA(re);                       // 输出re的值，print定义了输出得数必须在同一行，相邻字符之间加空格
    }
    public static int[] re(int[] a) {
        int[] ra = new int[a.length];
        for (int i = 0, j = a.length-1; i < a.length; i++, j--) {
            ra[j] = a[i];
        }
        return ra;
    }
    public static void printA(int[] a){    //将数组进行打印
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"\t");   //最后输出打印的地方
        }
    }
}

5	4	3	2	1

for each 循环（增强型for循环）

for(元素类型 元素变量 ：数组或集合){
}

多维数组

二维数组：int a[ ] [ ] =new int[2] [5] ;

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

    public static void main(String[]args) {
        int[][] arry={{1,2},{2,3},{3,4},{4,5}};
        printARRY(arry[0]);
    }
    public static void printARRY(int[] s){
        for (int i = 0; i < s.length; i++) {
            System.out.print(s[i]+"\t");
        }
    }

1 2
    
        public static void main(String[]args) {
        int[][] arry={{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i < arry.length; i++) {
            for (int j = 0; j < arry[i].length; j++) { // 定义了j只能从0跟1中取，因为{}里面只有两个数，所以j<2
                System.out.print(arry[i][j]+"\t");
            }
            System.out.println();
            
1	2	
2	3	
3	4	
4	5

Arrays类(java.util.Arrays)包下的——输出数组

    public static void main(String[]args) {
        int[] a={1,2,50,60,90,4,5,6,800};
        System.out.println(a);
    }


[I@4554617c             
 
     public static void main(String[]args) {
        int[] a={1,2,50,60,90,4,5,6,800};
        System.out.println(Arrays.toString(a));
    }
 
 
 [1, 2, 50, 60, 90, 4, 5, 6, 800]
 
 
     public static void main(String[]args) {
        int[] a={1,2,50,60,90,4,5,6,800};
        printArray(a);
    }
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+",");
        }
    }
 
 
 1,2,50,60,90,4,5,6,800,
 
 
     public static void main(String[]args) {
        int[] a={1,2,50,60,90,4,5,6,800};
        printArray(a);
    }
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.print(a[i]+"]");
            }
            else {
                System.out.print(a[i]+",");
            }
        }
    }
 
 
 [1,2,50,60,90,4,5,6,800]

排序+填充

    public static void main(String[]args) {
        int[] a={1,2,50,60,90,4,5,6,800};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4, 0);                    //在2-4之间填充0
        System.out.println(Arrays.toString(a));
        
       
[1, 2, 4, 5, 6, 50, 60, 90, 800]
[1, 2, 0, 0, 6, 50, 60, 90, 800]

冒泡排序（时间复杂度O(n2))**

    public static void main(String[]args) {
        int[] a={1,2,50,60,90,4,5,6,800};
        int[] s=sort(a);                               // 给public static int[]中sort做定义
        System.out.println(Arrays.toString(a));
    }
    public static int[] sort(int[] a) {
        int temp = 0;                                  //定义一个空对象
        for (int i = 0; i < a.length-1; i++) {         // 走a.length-1趟
            for (int j =0; j < a.length-1-i; j++) {    // 第一趟遍历7次，第二趟遍历6次，每循环一次就减少一次遍历
                if (a[j+1] < a[j]) {                   // 后一位大于前一位数的时候
                    temp = a[j];                       // 空对象就等于大的数
                    a[j] = a[j+1];                     // 小的一方等于小的数
                    a[j+1] = temp;                     // 大的一方等于空对象中大的数
                }
            }
        }
        return a;
    }


[1, 2, 4, 5, 6, 50, 60, 90, 800]


    public static void main(String[]args) {
        int[] a={1,2,50,60,90,4,5,6,800};
        int[] s=sort(a);                               // 给public static int[]中sort做定义
        System.out.println(Arrays.toString(a));
    }
    public static int[] sort(int[] a) {
        int temp = 0;                                  //定义一个空对象
        for (int i = 0; i < a.length-1; i++) {         // 走a.length-1趟
            boolean flag=false;
            for (int j =0; j < a.length-1-i; j++) {    // 第一趟遍历7次，第二趟遍历6次，每循环一次就减少一次遍历
                if (a[j+1] < a[j]) {                   // 后一位大于前一位数的时候
                    temp = a[j];                       // 空对象就等于大的数
                    a[j] = a[j+1];                     // 小的一方等于小的数
                    a[j+1] = temp;                     // 大的一方等于空对象中大的数
                    flag=true;
                }
            }
            if (flag==false){
               break;
            }
        }
        return a;
    }
}

[1, 2, 4, 5, 6, 50, 60, 90, 800]                     //将运算变得更简洁

如果是int类必须在结尾处加上return

**稀疏数组****（编写五子棋）

    public static void main(String[]args) {
    int[][] a=new int[11][11];                 // 创建11行11列二维数组， 0表示没有棋，1表示黑棋，2表示白棋
    a[1][2]=1;
    a[2][3]=2;      
        System.out.println("输出原始数组");      // 输出原始数组
        for (int[] ints:a) {
            for (int o:ints){
                System.out.print(o+"\t");
        }
            System.out.println();

    }
    }                                          // int默认值是0；


0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
    
    
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println(sum); 

2

//    输出稀疏数组 
    
        int[][] arry=new int[sum+1][3];        // 定义一个3行3列的二维数组
        arry[0][0]=11;
        arry[0][1]=11;
        arry[0][2]=sum;
        int count=0;                           //定义一个count变量，遍历二维数组，将非零的值，存放到稀疏数组中
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j]!=0){
                    count++;
                    arry[count][0]=i;          // 输出a数组中有数值的行
                    arry[count][1]=j;          // 输出a数组中有数值的列
                    arry[count][2]=a[i][j];    // 输出a数组具体值
                }
            }
        }
        System.out.println("输出稀疏数组");

        for (int i = 0; i < arry.length; i++) {
            System.out.println(arry[i][0]+"\t"+arry[i][1]+"\t"+arry[i][2]+"\t");
        }    
    

11	11	2	
1	2	1	
2	3	2
    
//    读取稀疏数组的值

        System.out.println("还原稀疏数组");
        int[][] arry3=new int[arry[0][0]][arry[0][1]];     // 定义arry3一个11行11列数组
        for (int i = 1; i < arry.length; i++) {            //给其中元素还原值
            arry3[arry[i][0]][arry[i][1]]=arry[i][2];
        }
        for (int[] h:arry3 ) {
            for (int m:h){
                System.out.print(m+"\t");
            }
            System.out.println();
        }

0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0         //没有值的话int默认值是0

注：不赋值的话int类型默认值是0，string类型默认值是null

Java内存

堆
- 存放new出来的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
栈(不new就是在栈中)
- 存放基本变量的类型—具体的值
方法区

数组越界和快捷键：

报错：ArrayIndexOutOfBoundsException

点击类的同时再按ctrl键可以进入类的编写

ctrl+F12：进入结构

ctrl+F5:运行快捷键

posted @ 2025-01-22 13:43 FoxDusk 阅读(7) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 数组和方法

· JAVA基础

· JAVA数组

· Java数组

· JAVA数组

阅读排行：
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 地球OL攻略 —— 某应届生求职总结
· 提示词工程——AI应用必不可少的技术
· Open-Sora 2.0 重磅开源！
· 周边上新：园子的第一款马克杯温暖上架

公告

昵称： FoxDusk
园龄： 2个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

JAVA数组

JAVA数组

Java内存

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜