JAVA数组

简介: 目录数组的定义和使用升级版for循环遍历数组 数组反转的操作 二维数组输入并传入方法打印 创建动态数组并将其从大到小排序 Arrays类 稀疏数组

数组的定义和使用

package jjava1;
public class demo1 {
public static void main(String[] args){
    int []nums;//定义数组
    nums=new int[10];//创建数组大小
for(int i=0;i<=9;i++){
    nums[i]=i;//赋值
}
int sum=0;
//获取数组长度:arrays.length
    for(int i=0;i<nums.length;i++)sum+=nums[i];//数组计算求和
System.out.println(sum);//打印总和
}
}

升级版for循环遍历数组

package jjava1;
public class demo02 {
    public static void main(String[] argc){
        int []a={1,2,3,4,5};
        for(int array:a){
            System.out.println(array);
        }
    }
}

数组反转的操作

package jjava1;
public class demo02 {
    public static void main(String[] argc){
        int []a={1,2,3,4,5};
        for(int array:a){
            System.out.println(array);
        }
        int[]reverse=reverse(a);
       for(int i=0;i< reverse.length;i++)
           System.out.println(reverse[i]);
    }
    public static int[] reverse(int[] a){
        int[] result=new int[a.length];
        //反转的操作
for(int i=0,j=result.length-1;i<a.length;i++,j--){
    result[j]=a[i];
}
return result;
    }
}

二维数组输入并传入方法打印

package jjava1;
import java.util.Arrays;
import java.util.Scanner;
public class j1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
int [][] kk=new int[3][4];
for(int i=0;i<kk.length;i++){
    for(int j=0;j<kk[i].length;j++){
        kk [i][j]=scanner.nextInt();
    }
}
suu(kk);
      // scanner.close();
    }
    public static void suu(int[][] cc){
        for(int i=0;i<cc.length;i++){
            for(int j=0;j<cc[i].length;j++){
               System.out.print(cc[i][j]+"\t");
            }System.out.println();
        }
    }
}
package jjava1;
import java.util.Arrays;
import java.util.Scanner;
public class j1 {
    public static void main(String[] args) {
        j1 suu=new j1();
        Scanner scanner = new Scanner(System.in);
int [][] kk=new int[3][4];
for(int i=0;i<kk.length;i++){
    for(int j=0;j<kk[i].length;j++){
        kk [i][j]=scanner.nextInt();
    }
}
suu(kk);
      // scanner.close();
    }
    public static void suu(int[][] cc){
        for(int i=0;i<cc.length;i++){
            for(int j=0;j<cc[i].length;j++){
               System.out.print(cc[i][j]+"\t");
            }System.out.println();
        }
    }
}

创建动态数组并将其从大到小排序

package step5;
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //动态创建数组
        int[] arr = new int[sc.nextInt()];
        for(int i = 0 ; i< arr.length ; i++){
            arr[i] = sc.nextInt();
        }
        /********** Begin **********/
        for(int j = 1 ; j< arr.length;j++){
            for (int i = 0; i < arr.length -j; i++) {
                if(arr[i] > arr[i+1]){
                    int temp = arr[i];//交换位置
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
        /********** End **********/
    }
}    

Arrays类

用Arrays.toString打印数组元素

package jjava1;
import java.util.Scanner;
import java.util.Arrays;
public class a1 {
    public static void main(String[] args){
Scanner a=new Scanner(System.in);
int[] aa={1,2,3,4,5};
print(1);
System.out.println(Arrays.toString(aa));
    }
    public static void print(int b){
                System.out.println(b);
    }
}

用fill进行数组填充

package jjava1;
import java.util.Scanner;
import java.util.Arrays;
public class a1 {
    public static void main(String[] args){
Scanner a=new Scanner(System.in);
  int[] aa={1,2,3,4,5,1,2,2,5,5};
System.out.println(Arrays.toString(aa));
Arrays.fill(aa,0);//数组填充
System.out.println(Arrays.toString(aa));
    }
}

用fill进行部分填充

package jjava1;
import java.util.Scanner;
import java.util.Arrays;
public class a1 {
    public static void main(String[] args){
Scanner a=new Scanner(System.in);
  int[] aa={1,2,3,4,5,1,2,2,5,5};
System.out.println(Arrays.toString(aa));
Arrays.fill(aa,2,5,0);//数组填充
System.out.println(Arrays.toString(aa));
    }
}

稀疏数组

package jjava1;
import java.util.Scanner;
import java.util.Arrays;
public class a1 {
    public static void main(String[] args){
Scanner a=new Scanner(System.in);
  int[][] aa=new int[11][11];
  aa[1][2]=1;
  aa[2][3]=1;
System.out.println("输出原始的数组");
for(int[] ints:aa){
    for(int anInt:ints){
        System.out.print(anInt+"\t");
    }
    System.out.println();
    //kkk(int aa[][]);
}
//Arrays.fill(aa,2,5,0);//数组填充
//System.out.println(Arrays.toString(aa));
//        System.out.println(Arrays.toString(aa));
//    }
//转换为稀疏数组保存
//获取有效值的个数
        System.out.println("==============");
  int sum=0;
for(int i=0;i<11;i++){
for(int j=0;j<11;j++){
    if(aa[i][j]!=0)sum++;
}
}
System.out.println("有效值的个数:"+sum);
//2.创建一个稀疏数组的数组
int[][] bb=new int[sum+1][3];
bb[0][0]=11;
bb[0][1]=11;
bb[0][2]=sum;
//遍历二维数组,将非零的值,存放稀疏数组中
int count=0;
for(int i=0;i<aa.length;i++){
    for(int j=0;j<aa[i].length;j++){
        if(aa[i][j]!=0){
            count++;
            bb[count][0]=i;
            bb[count][1]=j;
            bb[count][2]=aa[i][j];
        }
    }
}
//输出稀疏数组
    System.out.println("稀疏数组");
for(int i=0;i<bb.length;i++){
    System.out.println(
 bb[i][0]+"\t"+
 bb[i][1]+"\t"+ bb[i][2]+"\t"
    );
}
System.out.println("==========");
System.out.println("还原");
//1.读取稀疏数组
int[][] cc=new int[bb[0][0]][bb[0][1]];
//2.给其中的元素还原
for(int i=1;i<bb.length;i++){
    cc[bb[i][0]][bb[i][1]]=bb[i][2];
}
//3.打印
System.out.println("输出还原的数组");
for(int[] ints:cc){
    for(int anInt:ints){
        System.out.print(anInt+"\t");
    }System.out.println();
}
}
}
相关文章
|
5天前
|
存储 Java 索引
Java快速入门之数组、方法
### Java快速入门之数组与方法简介 #### 一、数组 数组是一种容器,用于存储同种数据类型的多个值。定义数组时需指定数据类型,如`int[]`只能存储整数。数组的初始化分为静态和动态两种: - **静态初始化**:直接指定元素,系统自动计算长度,如`int[] arr = {1, 2, 3};` - **动态初始化**:手动指定长度,系统给定默认值,如`int[] arr = new int[3];` 数组访问通过索引完成,索引从0开始,最大索引为`数组.length - 1`。遍历数组常用`for`循环。常见操作包括求和、找最值、统计特定条件元素等。
|
6天前
|
存储 Java 索引
Java基础(六):数组
Java基础(六):数组
Java基础(六):数组
|
4天前
|
存储 Java C++
Java数组:静态初始化与动态初始化详解
本文介绍了Java中数组的定义、特点及初始化方式。
30 12
|
3月前
|
存储 缓存 算法
Java 数组
【10月更文挑战第19天】Java 数组是一种非常实用的数据结构,它为我们提供了一种简单而有效的方式来存储和管理数据。通过合理地使用数组,我们能够提高程序的运行效率和代码的可读性。更加深入地了解和掌握 Java 数组的特性和应用,为我们的编程之旅增添更多的精彩。
42 4
|
3月前
|
存储 缓存 算法
提高 Java 数组性能的方法
【10月更文挑战第19天】深入探讨了提高 Java 数组性能的多种方法。通过合理运用这些策略,我们可以在处理数组时获得更好的性能表现,提升程序的运行效率。
52 2
|
3月前
|
存储 Java
Java“(array) <X> Not Initialized” (数组未初始化)错误解决
在Java中,遇到“(array) &lt;X&gt; Not Initialized”(数组未初始化)错误时,表示数组变量已被声明但尚未初始化。解决方法是在使用数组之前,通过指定数组的大小和类型来初始化数组,例如:`int[] arr = new int[5];` 或 `String[] strArr = new String[10];`。
116 2
|
3月前
|
存储 Java
什么是带有示例的 Java 中的交错数组?
什么是带有示例的 Java 中的交错数组?
65 9
|
3月前
|
Java
Java数组动态扩容和动态缩减
Java数组动态扩容和动态缩减
32 3
|
3月前
|
存储 算法 Java
Java一分钟之-数组的创建与遍历
数组作为Java中存储和操作一组相同类型数据的基本结构,其创建和遍历是编程基础中的基础。通过不同的创建方式,可以根据实际需求灵活地初始化数组。而选择合适的遍历方法,则可以提高代码的可读性和效率。掌握这些基本技能,对于深入学习Java乃至其他编程语言的数据结构和算法都是至关重要的。
35 6
|
3月前
|
存储 Java 程序员
【一步一步了解Java系列】:何为数组,何为引用类型
【一步一步了解Java系列】:何为数组,何为引用类型
41 1

热门文章

最新文章