Java-数组

已于 2023-10-13 16:52:45 修改
阅读量56 收藏
点赞数
分类专栏： Java 文章标签： java python 开发语言
于 2023-09-06 17:07:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43273590/article/details/131815845
版权

文章目录

1.概述

  • 数组可以看成是多个相同类型数据组合，对这些数据的统一管理。
  • 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

2.一维数组的声明

  • 声明格式：

    //type为数组类型，var为数组名
 type var[];
 type[] var;

 //例如：
 int a1[];int[] a2;
 double b[];
 Person[] p1;String s1[];

  • Java语言中声明数组时不能指定其长度（数组中元素的个数），例如：

    int a[5]; //非法

  • Java中使用关键字new创建数组对象，格式为：

    var = new type[数组元素的个数]

    public class Test {
	public static void main(String args[]){
    	int[] s;
    	s = new int[5];
    	System.out.println(s[1]);//输出：0
    	//为数组元素赋值，索引从0开始
    	for (int i = 0;i<5;i++){
        	s[i] = i;
    	}
    	System.out.println(s[1]);//输出：1
	}
}

  • 元素为引用数据类型的数组中的每一个元素都需要实例化

    public class Test {
    public static void main(String args[]){
        Date[] days;
        days = new Date[3];
        System.out.println(days[1]);//输出：null
        for (int i = 0;i<3;i++){
            days[i] = new Date(2020,7,1+i);
        }
        System.out.println(days[1].day);//输出：2
    }
}
class Date{
    int year;int month;int day;
    Date(int y,int m,int d){
        year = y;
        month = m;
        day = d;
    }
}

3.数组的初始化

1).动态初始化

  • 动态初始化：数组定义与数组元素分配空间和赋值的操作分开进行
    public class Test {
    public static void main(String args[]){
        int[] s;//定义数组
        s = new int[3];//分配空间
        s[0]=3;s[1]=9;s[2]=8;//赋值

        Date[] days;
        days = new Date[3];
        days[0] = new Date(2023,7,0);
        days[1] = new Date(2023,7,1);
        days[2] = new Date(2023,7,2);
    }
}
class Date{
    int year;int month;int day;
    Date(int y,int m,int d){
        year = y;
        month = m;
        day = d;
    }
}

2).静态初始化

  • 静态初始化：在定义数组的同时就为数组元素分配空间并赋值
    public class Test {
    public static void main(String args[]){
        int[] s = {3,9,8};
        int[] s1 = new int[]{3,9,8};//完整格式
        Date[] days = new Date{
        days[0] = new Date(2023,7,0),
        days[1] = new Date(2023,7,1),
        days[2] = new Date(2023,7,2)
        };
    }
}
class Date{
    int year;int month;int day;
    Date(int y,int m,int d){
        year = y;
        month = m;
        day = d;
    }
}

注：默认初始化
数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化。

  • 数组元素为int类型默认初始化为0
  • 数组元素为引用类型默认初始化为null

4.数组元素的引用

  • var[index]：index为数组元素下标，合法取值范围0~n-1（n为数组长度）
  • 每个数组都有一个属性length指明它的长度，例如：
    s.length   //数组s的长度（数组s的元素个数）

5.一维数组的练习

1).数组的输出和String[] args的用法

package Array;
public class TestArray {
	public static void main(String[] args) {
		int[] a = {2, 4, 6, 7, 3, 5, 1, 9, 8};

		/*
		for(int i=0; i<a.length; i++) {
			System.out.print(a[i] + " ");//遍历输出
		}
		*/
		
		for(int i=0; i<args.length; i++) {
			System.out.println(args[i]);
		}
	}
}

数组args的用法：
在这里插入图片描述

2).实现加减乘除

package Array;
public class TestArgs {
    public static void main(String[] args) {
        if (args.length < 3) {
            System.out.println(
                    "Usage: java Test \"n1\" \"op\" \"n2\"");
            System.exit(-1);
        }
        double d1 = Double.parseDouble(args[0]); //String类型强制转换为Double类型
        double d2 = Double.parseDouble(args[2]);
        double d = 0;
        if (args[1].equals("+")) d = d1 + d2;
        else if (args[1].equals("-")) d = d1 - d2;
        else if (args[1].equals("x")) d = d1 * d2;
        else if (args[1].equals("/")) d = d1 / d2;
        else {
            System.out.println("Error operator!");
            System.exit(-1);
        }
        System.out.println(d);
    }
}

例：
在这里插入图片描述

3).读入并排序

要求：依靠args读入2, 4, 6, 7, 3, 5, 1, 9, 8；并按从小到大排序

package Array;
public class NumSort {
	public static void main(String[] args) {
		int[] a = new int[args.length];
		//String转换成int
		for (int i=0; i<args.length; i++) {
			a[i] = Integer.parseInt(args[i]);
		}
		print(a);
		selectionSort(a);
		print(a);
	}
	//排序
	private static void selectionSort(int[] a) {
		for(int i=0; i<a.length; i++) {
			for(int j=i+1; j<a.length; j++) {
				//每次找到更小值都交换
				if(a[j] < a[i]) {
					int temp = a[j];
					a[j] = a[i];
					a[i] = temp;
				}
			}
		}
	}
	//排序（效率更高，每次只做一次交换）
	private static void selectionSort2(int[] a) {
		int k, temp;
		for(int i=0; i<a.length; i++) {
			k = i;
			//找到最小值的索引
			for(int j=k+1; j<a.length; j++) {
				if(a[j] < a[k]) {
					k = j;
				}
			}
			//交换最小值与当前值
			if(k != i) {
				temp = a[i];
				a[i] = a[k];
				a[k] = temp;
			}
		}
	}
	//将数组打印出来
	private static void print(int[] a) {
		for(int i=0; i<a.length; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
}

4).冒泡排序

package Array;

public class TestDateSort {
    public static void main(String[] args) {
        Date[] days = new Date[5];
        days[0] = new Date(2006, 5, 4);
        days[1] = new Date(2006, 7, 4);
        days[2] = new Date(2008, 5, 4);
        days[3] = new Date(2004, 5, 9);
        days[4] = new Date(2004, 5, 4);

        Date d = new Date(2006, 7, 4);
        String str = String.valueOf(d);
        //str = d.toString();
        bubbleSort(days);

        for (int i = 0; i < days.length; i++) {
            System.out.println(days[i]);
        }
        System.out.println(binarySearch(days, d));
    }

    //冒泡排序：每次循环将最大的值挪到最后
    public static Date[] bubbleSort(Date[] a) {
        int len = a.length;
        for (int i = len - 1; i >= 1; i--) {
            for (int j = 0; j <= i - 1; j++) {
                if (a[j].compare(a[j + 1]) > 0) {
                    Date temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        return a;
    }

    //二分法查找
    public static int binarySearch(Date[] days, Date d) {
        if (days.length == 0) return -1;

        int startPos = 0;
        int endPos = days.length - 1;
        int m = (startPos + endPos) / 2;
        while (startPos <= endPos) {
            if (d.compare(days[m]) == 0) return m;
            if (d.compare(days[m]) > 0) {
                startPos = m + 1;
            }
            if (d.compare(days[m]) < 0) {
                endPos = m - 1;
            }
            m = (startPos + endPos) / 2;
        }
        return -1;
    }
}

class Date {
    int year, month, day;

    Date(int y, int m, int d) {
        year = y;
        month = m;
        day = d;
    }

    //比较年月日大小
    public int compare(Date date) {
        return year > date.year ? 1
                : year < date.year ? -1
                : month > date.month ? 1
                : month < date.month ? -1
                : day > date.day ? 1
                : day < date.day ? -1 : 0;
    }

    //重写toString方法，否则返回的是类名和它的引用地址
    public String toString() {
        return "Year:Month:Day -- " + year + "-" + month + "-" + day;
    }
}

5).数三退一

第一种

package Array;
public class Count3Quit {
	public static void main(String[] args) {
		boolean[] arr = new boolean[500];
		for(int i=0; i<arr.length; i++) {
			arr[i] = true;
		}
		
		int leftCount = arr.length;
		int countNum = 0;
		int index = 0;
		while(leftCount > 1) {
			if(arr[index] == true) {
				countNum ++;
				if(countNum == 3) {
					countNum = 0;
					arr[index] = false;
					leftCount --;
				}
			}
			index ++;
			if(index == arr.length) {
				index = 0;
			}
		}
		
		for(int i=0; i<arr.length; i++) {
			if(arr[i] == true) {
				System.out.println(i);
			}
		}
	}
}

第二种

package Array;

public class Count3Quit2 {
	public static void main(String[] args) {
		KidCircle kc = new KidCircle(500);
		int countNum = 0;
		Kid k = kc.first;
		while(kc.count > 1) {
			countNum ++;
			if(countNum == 3) {
				countNum = 0;
				kc.delete(k);
			}
			k = k.right;
		}
		
		System.out.println(kc.first.id);
	}
}

class Kid {
	int id;
	Kid left;
	Kid right;
}

class KidCircle {
	int count = 0;
	Kid first, last;
	
	KidCircle(int n) {
		for(int i=0; i<n; i++) {
			add();
		}
	}
	
	void add() {
		Kid k = new Kid();
		k.id = count;
		if(count <= 0) {
			first = k;
			last = k;
			k.left = k;
			k.right = k;
		} else {
			last.right = k;
			k.left = last;
			k.right = first;
			first.left = k;
			last = k;
		}
		count ++;
	}
	
	void delete(Kid k) {
		if(count <= 0) {
			return;
		} else if (count == 1) {
			first = last = null;
		} else {
			k.left.right = k.right;
			k.right.left = k.left;
			
			if(k == first) {
				first = k.right;
			} else if( k == last) {
				last = k.left;
			}
		}
		count --;
	}
}

6).二分法查找

package Array;

public class TestSearch {
    public static void main(String[] args) {
        int a[] = {1, 3, 6, 8, 9, 10, 12, 18, 20, 34};
        int i = 12;
        //System.out.println(search(a, i));
        System.out.println(binarySearch(a, i));
    }

    public static int search(int[] a, int num) {
        for (int i = 0; i < a.length; i++) {
            if (a[i] == num) return i;
        }
        return -1;
    }
    
    //二分法查找
    public static int binarySearch(int[] a, int num) {
        if (a.length == 0) return -1;
        int startPos = 0;
        int endPos = a.length - 1;
        int m = (startPos + endPos) / 2;
        while (startPos <= endPos) {
            if (num == a[m]) return m;
            if (num > a[m]) {
                startPos = m + 1;
            }
            if (num < a[m]) {
                endPos = m - 1;
            }
            m = (startPos + endPos) / 2;
        }
        return -1;
    }

}

6.二维数组

  • 二维数组可以看成以数组为元素的数组。例如：
    int a[][] ={{1,2},{3,4,5,6},{7,8,9}};
  • Java中多维数组的声明和初始化应按从高维到低维的顺序进行，例如：
    int a[][] = new int[3][];
a[0] = new int[2];
a[1] = nwe int[4];
a[2] = nwe int[3];
int t[][] = new int[][4];//非法

二维数组的初始化

1).静态初始化

 int intA[][] = {{1,2},{2,3},{3,4,5}};
 int intA[3][2] = {{1,2},{2,3},{4,5}};//非法

2).动态初始化

 int a[][] = new int[3][5];
 
 int b[][] = new int[3][];
 b[0] = new int[2];
 b[1] = nwe int[3];
 b[2] = nwe int[5];

7.数组的拷贝

  • 使用java.lang.system类的静态方法
    public static void arraycopy(Object src,int srcPos,Object destint,destPos,int length)
  • 可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置。
  • 如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常
package Array;

public class TestArrayCopy {
  public static void main(String args[]) {
    String[] s = 
            {"Mircosoft","IBM","Sun","Oracle","Apple"};
    String[] sBak = new String[6];
    System.arraycopy(s,0,sBak,0,s.length);
    
    for(int i=0;i<sBak.length;i++){
      System.out.print(sBak[i]+" ");
    }
    System.out.println();
    
    int[][] intArray = {{1,2},{1,2,3},{3,4}};
    int[][] intArrayBak = new int[3][];
    System.arraycopy
            (intArray,0,intArrayBak,0,intArray.length);
    intArrayBak[2][1] = 100;
    
    for(int i = 0;i<intArray.length;i++){
        for(int j =0;j<intArray[i].length;j++){
            System.out.print(intArray[i][j]+"  "); 
        }
        System.out.println();
    }
  }
}
宋夏寒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌--Java入门 - 数组进阶
m0_56638814的博客
04-30 5721
头歌--Java入门 - 数组进阶
Java-数组拆分
weixin_60588588的博客
11-06 1416
给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从 1 到 n 的 min(ai, bi) 总和最大。 返回该 最大总和 。
java-数组常用api
weixin_46469774的博客
03-20 2752
Java 数组相关api  数组array中的api 1.获取数组长度： arrays .length() 在Java中要求一个数组的长度是可以直接用length属性来获取的int []A = {1,2,3}; int len = A.length; 在Java中这种方式就可以直接获取到数组的长度。值得注意的是，在Java中还有一个length()方法。这个方法是针对字符串而言的，只能用来求字符串长度。此外还有一个size()方法，是用来求泛型集合元素个数的。 注意：Java和C++中都有length()
JAVA-数组和List转换
weixin_46690278的博客
03-30 9713
日常开发时，经常遇到需要List与数组互相转换的场景。 List转换成数组，可以用List的toArray()或者toArray(T[] a)的方法。 数组转换成List，可以用Arrays.asList()或者Collections.addAll()方法。 如果仅仅为了打印数组，不需要把数组转换成List， 可以使用Arrays.toString()方法。 一.List转数组 List转换成数组可以调用toArray方法，可以将List直接转为Object[]数组 这里有两个重载的方法， 一般使用带泛
java float数组赋值_double 数组_java-数组
weixin_30268555的博客
03-01 3684
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。Java 语言中提供的数组是用来存储固定大小的同类型元素。你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。本教程将为大家介绍 Java 数组的声明、创建和初始化，并给出其对应的代码。声明数组变量首先必须声明...
头歌（educoder）第 3 章 Java入门之数组 Java入门 - 数组基础
qq_35353972的博客
09-19 9849
头歌（educoder）第 3 章 Java入门之数组 Java入门 - 数组基础
Java-数组实现超简易学生管理系统
m0_53428376的博客
10-19 1615
System.out.println("学号：" + s[i].getSutID() + " 姓名：" + s[i].getName() + " 年龄：" + s[i].getAge()+" 班级："+ Student.getClasses());System.out.println("------欢迎来到学生管理系统------");System.out.println("没得学生了，请先添加学生");System.out.println("没得学生了，请先添加学生");
java-数组-找数组中的最大值
ITGGU的博客
01-09 6455
数组-找数组中的最大值 求数组中的最大值，并得到对应的下标 思路分析 1.定义一个数组 2.假定一个元素为最大值max=arr[0],maxIndex=当前元素下标 3.遍历比较 public class ArrayExercise02{ public static void main(String[] args){ //求数组中的最大值，并得到对应的下标 //思路分析 //1.定义一个数组 //2.假定一个元素为最大值max=arr[0],maxIndex=当前元素下标 //3.遍历
Java-数组列表（ArrayList）
Gold_Medal的博客
05-21 5108
Java-数组列表（ArrayList） ArrayList类是一个特殊的数组--动态数组。 普通的数组是静态的，只有先确定了他的大小才能给它初始化赋值或者参与运算，而且这个大小一但初始化后是不能被修改的，所以当你刚开始不确定你要输入数据的多少时，普通的数组不容易实现（万一你输入的数据多于数组大小时，就会数组溢出，导致报错），为此java有了" 数组列表"(ArrayList)。 （小声bb：其实我感觉ArrayList，甚至是Java的整个集合类，都有与C++里的STL类...
java-数组转字符串
MySQL中主从连接可能出现的问题
12-30 1336
Java-数组转字符串
Educoder题目：Java入门 - 数组进阶答案解析.md
11-01
Educoder题目：Java入门 - 数组进阶答案解析
Java - 数组面试题 - 个人整理
08-20
数组 - 需要参加面试的人
Java-数组实验.pdf
10-03
【Java 数组基础与文件操作】\n\nJava 数组是一种数据结构，它允许程序员存储固定数量的相同类型的数据。数组在 Java 中是基础且重要的概念，它提供了一种高效的方式来组织和处理数据。本实验旨在帮助你深入理解数组...
JAVA-数组进制转换
10-08
.java文件，对java基础的数组部分的进制类型转换部分的说明。
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 786
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
日常工作记录目录
与海
06-21 154
EasyExcel实现二维码下载与展示
Day43
m0_67496588的博客
06-20 1059
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 258
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 885
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Java基础--数组练习2
07-25
Java基础--数组练习2 在Java中，数组是一种用来存储一组相同数据类型的数据的容器。它的特点包括数组是一个引用数据类型，数组内部可以存储基本类型或引用类型...愿大家在学习Java数组练习过程中取得更进一步的进步！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值