Java——引用数据类型—数组

最新推荐文章于 2023-08-29 15:19:00 发布
最新推荐文章于 2023-08-29 15:19:00 发布
阅读量756 收藏 4
点赞数 1
分类专栏： 小白学Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53861505/article/details/129189166
版权

一.数组

1.一维数组

含义：一组数据的容器

作用：存储多个数据

数组的声明：

​ 数据类型[] 数组名/变量名；

注意：

  1. 数组是引用数据类型

  2. 数组中的数据，称之为元素

  3. 每个元素都有编号，称之为下标/索引

  4. 下标从0开始

  5. 下标的作用：通过下标可以定位到数组中的某个位置

  6. 数组一旦初始化成功，长度将不可改变

  7. 操作数组：

    改 - 通过下标设置元素
    查 - 通过下标获取元素
    查 - 获取元素个数
    查 - 遍历数组

数组的初始化：

静态初始化：数据由程序员给定，长度由系统分配

public class Test{
	public static void main(String[] args){
	
		//静态初始化一
		//String[] names = new String[]{"AA","BB","CC","DD","EE"};
		
		//静态初始化二(先声明再初始化)
		//String[] names;
		//names = new String[]{"AA","BB","CC","CC","DD"};
		
		//静态初始化三（简化写法1）
		String[] names = {"AA","BB","CC","DD","EE"};
		
		//通过下标设置元素
		names[2] = "FF";
		
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//下标从0开始，不超过数组的长度
		//names[5] = "xxx";
		
		
		//通过下标获取元素
		String str = names[2];
		System.out.println("通过下标获取元素：" + str);
		
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("-----------");
		
		//遍历数组 -- for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("-----------");
		
		//遍历数组 -- foreach/增强for循环
		for(String element : names){//依次将元素赋值给element
			System.out.println(element);
		}
		
		/**
			for vs foreach
				遍历时，使用到下标 -- for
				遍历是，不使用下标 -- foreach
		*/
		
	}
	
}

动态初始化:

长度由程序员给定，数据由系统分配默认值

整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null（空）

public class Test{
	public static void main(String[] args){
	
		//动态初始化一
		//String[] names = new String[5];//5-数组的的长度
		
		//动态初始化二(先声明再初始化)
		String[] names;
		names = new String[5];
		
		//通过下标设置元素
		names[0] = "AA";
		names[1] = "BB";
		names[2] = "CC";
		names[3] = "DD";
		names[4] = "EE";
		
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//下标从0开始，不超过数组的长度
		//names[5] = "xxx";
		
		
		//通过下标获取元素
		String str = names[2];
		System.out.println("通过下标获取元素：" + str);
		
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("-----------");
		
		//遍历数组 -- for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("-----------");
		
		//遍历数组 -- foreach/增强for循环
		for(String element : names){//依次将元素赋值给element
			System.out.println(element);
		}
		
		/**
			for vs foreach
				遍历时，使用到下标 -- for
				遍历是，不使用下标 -- foreach
		*/
		
	}
	
}

一维数组的应用：

需求：创建一个int数组，长度让用户指定，数据有用户输入，获取数组中的最大值

import java.util.Scanner;
public class Test{
	public static void main(String[] args){
	
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入数组的长度：");
		int len = scan.nextInt();
		
		if(len <= 0){
			System.out.println("长度有误~~");
			return;
		}
	
		//动态初始化数组
		int[] is = new int[len];
		
		//循环输入
		for(int i = 0;i<is.length;i++){
			System.out.println("请输入第" + (i+1) + "个数字：");
			int num = scan.nextInt();
			is[i] = num;
		}
		
		//获取数组中的最大值
		
		int max = is[0];//假设数组第一个元素为最大值
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
		}	
		System.out.println("最大值为：" + max);	
	}	
}
1.1 冒泡排序
public class Test{
	/**
        N个数字来排队
        两辆相比小靠前
        外层循环N-1
        内层循环N-1-i
	*/
	public static void main(String[] args){
		
		int[] nums = {81,23,56,18,33,9};
		
		for(int i = 0;i<nums.length-1;i++){
			for(int j = 0;j<nums.length-1-i;j++){
				if(nums[j] > nums[j+1]){
					int temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = temp;
				}
			}
		}
		
		for(int element : nums){
			System.out.println(element);
		}
		
	}
	
	
}
1.2 线性查找/顺序查找
public class Test{
	public static void main(String[] args){
		
		int[] nums = {81,23,56,18,33,9};
		
		int num = 18;//需要查找的值
		
		for(int i = 0;i<nums.length;i++){
			if(nums[i] == num){
				System.out.println("找到元素了，下标为：" + i);
				break;
			}
		}
	}
	
	
}
1.3 二叉查找/二分法查找
import java.util.Arrays;
public class Test{
	/**
		知识点：数组的查找 -- 二叉查找/二分法查找
		
		注意：必须先排序
		
	*/
	public static void main(String[] args){
		
		int[] nums = {81,23,56,18,33,9};
		
		int num = 18;//需要查找的值
		
		//数组的排序 -- 9,18,23,33,56,81
		Arrays.sort(nums);
		
		int start = 0;
		int end = nums.length-1;
		
		while(start <= end){
			int mid = (start+end)/2;
			
			if(nums[mid] > num){
				end = mid-1;
			}else if(nums[mid] < num){
				start = mid+1;
			}else{
				System.out.println("找到元素了，下标为：" + mid);
				break;
			}
			
		}
		
	}

}
1.4 数组的复制
public class Test{
	/**
		知识点：数组的复制1
		
		缺点：修改源数组，新数组也会发生改变
		
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};
		
		//新数组
		String[] newNames = names;
		
		//修改源数组的数据
		names[1] = "EE";
		
		//遍历新数组
		for(String str : newNames){
			System.out.println(str);
		}
		
	}
}

public class Test{
	/**
		知识点：数组的复制2		
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};
		
		//新数组
		String[] newNames = new String[names.length];
		
		//数据的复制
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
		
		//修改源数组的数据
		names[1] = "EE";
		
		//遍历新数组
		for(String str : newNames){
			System.out.println(str);
		}
		
	}
}
1.5 数组的扩容
public class Test{
	/**
		知识点：数组的扩容	

		扩容机制：原来长度的1.5
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};
		
		//老的长度
		int oldCapacity = names.length;
		//新的长度
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		
		//创建新数组
		String[] newNames = new String[newCapacity];
		
		//将源数组的数据复制到新数组中
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
		
		//将新数组的地址复制给源数组
		names = newNames;
		
		//遍历源数组
		for(String str : names){
			System.out.println(str);
		}		
	}
}
1.6 数组的删除
public class Test{
	/**
		知识点：数组的删除1
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};//0,1,2,3
		
		//创建新数组
		String[] newNames = new String[names.length-1];//0,1,2
		
		//遍历源数组，将除了"BB"的元素都放入新数组中
		int index = 0;
		for(String element : names){
			if(!element.equals("BB")){
				newNames[index++] = element;
			}
		}
		
		//将新数组的引用复制给原数组
		names = newNames;
		
		//遍历源数组
		for(String element : names){
			System.out.println(element);
		}
	}
}

public class Test{
	/**
		知识点：数组的删除2
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};//0,1,2,3
		
		//数据的迁移
		for(int i = 1;i<names.length-1;i++){
			names[i] = names[i+1];
		}
		
		//把最后一个元素置为null
		names[names.length-1] = null;
		
		//遍历源数组
		for(String element : names){
			System.out.println(element);
		}
	}
}

2. Arrays工具类——专门操作数组的工具类

Simport java.util.Arrays;
public class Test11{
	/**
		知识点：Arrays工具类
		含义：Java给我们提供的专门操作数组的工具类
		
		工具类的概念：该类中所有的方法都是静态的，直接使用类名调用
		API的概念：Java提供类的说明书（放在桌面去，方便我们查询）
		
	*/
	public static void main(String[] args){
		
		int[] nums = {81,23,56,18,33,9};
		
		//排序 -- 9,18,23,33,56,81
		Arrays.sort(nums);
		
		//查找
		//返回值：搜索键的索引，如果它包含在数组中;否则， (-(insertion point) - 1) 
		//返回值：如果查找的值在数组中，就返回下标;否则，返回(-插入点-1)
		int index = Arrays.binarySearch(nums,40);
		System.out.println(&quot;查找元素的下标为：&quot; + index);
		
		//拷贝数组(目标数组,新的长度)
		int[] arr1 = Arrays.copyOf(nums,nums.length*2);
		
		//拷贝数组(目标数组,开始下标-包含,结束下标-不包含)
		int[] arr2 = Arrays.copyOfRange(arr1,2,8);
		
		//替换(目标数组,要替换的值)
		Arrays.fill(arr2,888);
		
		//替换(目标数组,开始下标-包含,结束下标-不包含,要替换的值)
		Arrays.fill(arr2,1,4,666);
	
		//将数组转换为字符串 -- [23,33,56,81,0,0]
		System.out.println(Arrays.toString(arr2));
	}
}

2.二维数组

2.1 静态初始化

public class Test{
	/**
		知识点：二维数组
		
		含义：包含了多个一维数组
		
		数组的声明：
			数据类型[][] 数组名;

	*/
	public static void main(String[] args){
		
		//静态初始化一
		//String[][] names = new String[][]{{"AA","BB","CC"},{"DD","EE","FF","GG"}};
		
		//静态初始化二(先声明，再初始化)
		//String[][] names;
		//names = new String[][]{{"AA","BB","CC"},{"DD","EE","FF","GG"}};
		
		//静态初始化三(简化写法一)
		String[][] names = {{"AA","BB","CC"},{"DD","EE","FF","GG"}};
		
		//设置指定下标上的元素
		names[1][1] = "NN";
		
		//获取指定下标上的元素
		String str = names[1][1];
		System.out.println("获取指定下标上的元素：" + str);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组元素的个数：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组元素的个数：" + names[1].length);//4
		
		System.out.println("-----------");
		
		//遍历思路：先循环取出二维数组中的一维数组，再循环取出一维数组中的元素
		
		//遍历数组 -- for
		for(int i = 0;i<names.length;i++){
			for(int j = 0;j<names[i].length;j++){
				System.out.println(names[i][j]);
			}
		}
		
		System.out.println("-----------");
		
		//遍历数组 -- foreach
		for(String[] ss : names){
			for(String element : ss){
				System.out.println(element);
			}
		}
	
	}
}

2.2 动态初始化

public class Test{
	/**
		知识点：二维数组
		
		含义：包含了多个一维数组
		
		数组的声明：
			数据类型[][] 数组名;

	*/
	public static void main(String[] args){
		
		//动态初始化一
		//String[][] names = new String[2][3];//2-创建2个一维数组  3-每个一维数组有3个元素
		
		//动态初始化二（先声明，再初始化）
		String[][] names;
		names = new String[2][3];//2-创建2个一维数组  3-每个一维数组有3个元素
		
		
		//设置指定下标上的元素
		names[0][0] = "aa";
		names[0][1] = "bb";
		names[0][2] = "cc";
		names[1][0] = "dd";
		names[1][1] = "ee";
		names[1][2] = "ff";
		
		//获取指定下标上的元素
		String str = names[1][1];
		System.out.println("获取指定下标上的元素：" + str);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组元素的个数：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组元素的个数：" + names[1].length);//4
		
		System.out.println("-----------");
		
		//遍历思路：先循环取出二维数组中的一维数组，再循环取出一维数组中的元素
		
		//遍历数组 -- for
		for(int i = 0;i<names.length;i++){
			for(int j = 0;j<names[i].length;j++){
				System.out.println(names[i][j]);
			}
		}
		
		System.out.println("-----------");
		
		//遍历数组 -- foreach
		for(String[] ss : names){
			for(String element : ss){
				System.out.println(element);
			}
		}
	
	}
}
小白入学Java
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java【数组】定义与使用，什么是引用类型你知道吗
yzhcjl_的博客
11-06 2269
数组的定义和使用，引用类型到底是什么，关于数组的库方法，你都会嘛
java关于数组（学习笔记）
12-21
关于数组Array（学习笔记） 简介： 数组就是一个容器，可以同时容纳多个元素。意思是“一组数据”。 Java语言中的数组是一种引用数据类型。不属于基本数据类型，父类同样是Object类。因为是引用数据类型，所以数组的对象存储在堆内存中。如果存储的是Java对象的话，实际存储是对象的引用（内存地址），数组中不能直接存储Java对象。 数组在内存方面存储的时候，数组的内存地址是连续的（存储的每个数据都是按顺序排列的）。数组的第一个小方框的内存地址作为这个数组对象的内存地址。 数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。java中要求数组中元素的类型要统一。比如int
java——数组.xmind
07-10
一维数组概念：一组连续的存储空间，存储多个相同数据类型的值。数组的创建。数组的组成。数组的遍历。数组的默认值。
Java引用数据类型之数组
11-16 363
一.数组定义 同一种类型数据的集合。其实数组就是一个容器。 二.数组格式 格式一 ：数据类型[] 数组名 = new 数据类型[数组长度]; 格式二 ：数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3}; 格式三 ：数据类型[] 数组名 = {数据1,数据2,数据3}; public class GArray { public static void main(Stri
【Java基础(五)】引用数据类型-数组
haolinbird的博客
09-05 895
数组是相同类型数据的有序集合数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
java的数据类型：引用数据类型（String、数组、枚举）
yu的博客
01-19 5475
java的数据类型：引用数据类型（String、数组、枚举）
java中引用数据类型
抓饭不吃皮牙子
08-12 983
以上代码示例展示了Java中引用数据类型的使用，包括对象的创建和属性访问、数组的初始化和元素访问、以及接口的定义和实现。这些示例演示了引用数据类型在Java中的基本用法。在Java中，引用数据类型是指那些不直接存储数据值，而是存储对数据值的引用的数据类型。Java中的引用数据类型包括对象、数组和接口。
java数组的引用
cjh1107987880的博客
09-18 2643
//数组的引用举例 //数组是引用型变量，如果两个相同类型的数组具有相同的引用，它们就有完全相同的元素 //引用就是内存单元的的首地址，存放在数组变量中 public class Example2_4 { public static void main(String args[]){ int a[]={1,2,3,4}; int b[]={100,200,300}; System.out.println("数组a的元素个数="+a.length);...
Java数组及引用
qq_64552046的博客
03-12 1398
Java数组及引用
引用数据类型之数组
最新发布
weixin_67721274的博客
08-29 196
数组
学习Java，你需要知道这些——Java数组
01-21
数组由同一类型的对象或者基本数据组成,并封装在同一一个标识符(数组名称)下。 数组是对象 动态初始化 可以赋值给Object类型的变量 在数组中可以调用类Object的所有方法 二每个数组都有一 个由public final修饰的...
Java程序设计基础：数组的概念.pptx
05-26
数组是一组名字相同下标不同，数据类型相同的变量的集合。 由下标来区分不同的数组元素，如a[0] , a[1] ，…，a[n],下标是从0开始的非负整数，必须用一对方括号括起来。 数组元素也称为下标变量，在内存中是连续存放...
java集合——全
12-22
集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 说明:此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中) 数组存储的特点： 一旦初始化以后，其长度就确定了。 ...
Java基础Note——流程语句及方法和数组
12-22
没有long并且支持的引用类型都是以上四个基本数据类型的包装类， java5和7后支持枚举和String类。注意：只要进入一个case后其它的case都会忽略，所以如果没有break则会一直向下执行（穿透）。case后面不能有{} 循环 ...
java引用类型之数组
m0_74302039的博客
07-25 67
引用相当于一个别名",也可以理解成一个指针创建一个引用只是相当于创建了一个很小的变量这个变量保存了一个整数这个整数表示内存中的一个地址当一个引用被赋值为null的时候，代表这个引用不指向任何对象；
JAVA基本语法：引用数据类型的使用——数组
AI_drag0n的博客
12-01 917
数组： 数组：是存储多个变量（元素）的集合/容器，但是多个变量的数据类型要一致。 注意事项： 数组中变量的数据类型要一致； 数组本身是引用数据类型，但是既可以保存基本数据类型，也可以保存引用数据类型。 数组的长度一旦给定无法改变。 -----------&gt;  解决方案：动态数组类(重新开辟内存) 一维数组只有第一次定义的时候可以简写，重新赋值的时候不能简写。 静态初始化中数组长...
JAVA引用类型（1）——数组
qq_42424228的博客
07-19 2248
数组是一种容器，可以同时存放多个相同数据类型的数据 数组是一种引用类型，其长度在程序运行期间不可以改变 初始化 动态初始化（指定长度）： 格式： 数据类型[] 数组名称 =new 数据类型[数据长度]； 左右俩侧数据类型必须相同。int[] str = new int[10]; short[] str2 = new short[200]; String[] str3 = new String[20]; 静态初始化（指定内容） 静态初始化的长度由初始化的数据个数决定。 基本格式：数据类型[] 数组名称 =
Java017——引用数据类型《数组》的简单学习
weixin_45084986的博客
06-19 339
数组是有限个相同类型的数据的有序集合；其中，每一个数据称作一个数组元素；每个数组元素可以通过一个下标来访问它们.
六年面试经验来分享JAVA基础面试题
weixin_51072772的博客
10-12 3853
来源 | 极链AI云（性价比最高的共享GPU算力平台，双十活动进行中 10.9-10.11，充值就送！最多可送2500元现金券！免费试用地址：https://cloud.videojj.com/） 1.面向对象和面向过程的区别 面向过程 优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源。比如单片机、嵌入式开发、Linux/Unix，等一般采用面向过程开发，性能是最重要的因素。 缺点：没有面向对象易维护、易复用、易扩展 面向对象 优点：易维护、易复用、易扩展，由于面向对象有
java中数组的用法
08-23
在Java中，数组是一种用于存储多个相同类型的数据的数据结构。数组的用法包括声明、初始化、访问和遍历。 1. 声明数组：可以使用以下方式声明数组： - `int[] arr;`：声明一个整型数组 - `String[] names;`：声明一个字符串数组 - `double[] scores;`：声明一个双精度浮点数数组 2. 初始化数组：可以使用以下方式初始化数组： - `arr = new int;`：初始化一个长度为5的整型数组 - `names = new String[]{"Alice", "Bob", "Charlie"};`：初始化一个包含指定元素的字符串数组 - `scores = {98.5, 87.0, 92.5};`：简化形式的初始化数组 3. 访问数组：可以使用索引来访问数组中的元素，索引从0开始计数。例如，`arr`表示数组中的第一个元素，`names`表示数组中的第三个元素。 4. 遍历数组：可以使用循环结构来遍历数组中的所有元素。例如，可以使用for循环来遍历整型数组： ``` for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } ``` 5. 数组拷贝：可以使用`System.arraycopy()`方法或`Arrays.copyOf()`方法来进行数组的拷贝操作。 6. 数组排序：可以使用`Arrays.sort()`方法对数组进行排序。 7. 不规则数组：Java中也支持不规则数组，即数组中的元素可以是数组。例如，可以创建一个二维数组`int[][] array`，其中每个元素都是一个一维数组。可以通过循环嵌套来遍历和访问不规则数组中的元素。 以上是Java中数组的基本用法。可以根据具体的需求和情况使用数组来存储和处理数据。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Java——数组的使用](https://blog.csdn.net/qq_59599094/article/details/127728786)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值