Arrays工具类

最新推荐文章于 2024-04-28 18:49:50 发布
最新推荐文章于 2024-04-28 18:49:50 发布
阅读量381 收藏
点赞数
分类专栏： JavaSE 文章标签： Arrays类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Amanda_wjx/article/details/88978206
版权

Arrays工具类

介绍：
专家提供的，专门用来操作数组的工具类，这个类中很多方法可以帮助我们操作数组；
它位于java.util包下，使用时要import导包，它的方法都是静态的，可以用类名.方法名 这个格式调用；
在这里插入图片描述
方法摘要：

      所有方法  
      静态方法  
      具体的方法  
      Modifier and Type Method and Description

static List asList(T… a) 返回由指定数组支持的固定大小的列表。
static int binarySearch(byte[] a, byte key) 使用二进制搜索算法搜索指定值的指定字节数组。
static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key) 使用二进制搜索算法搜索指定值的指定字节数组的范围。
static int binarySearch(char[] a, char key) 使用二进制搜索算法搜索指定数组的指定值。
static int binarySearch(char[] a, int fromIndex, int toIndex, char key) 使用二分搜索算法搜索指定值的指定数组的范围。
static int binarySearch(double[] a, double key) 使用二进制搜索算法搜索指定值的指定数组的双精度值。
static int binarySearch(double[] a, int fromIndex, int toIndex, double key) 使用二分搜索算法搜索指定值的指定数组的双精度范围。
static int binarySearch(float[] a, float key) 使用二叉搜索算法搜索指定数组的浮点数。
static int binarySearch(float[] a, int fromIndex, int toIndex, float key) 使用二分搜索算法搜索指定数组的浮点数范围。
static int binarySearch(int[] a, int key) 使用二叉搜索算法搜索指定的int数组的指定值。
static int binarySearch(int[] a, int fromIndex, int toIndex, int key) 使用二叉搜索算法搜索指定值的指定数组的范围。
static int binarySearch(long[] a, int fromIndex, int toIndex, long key) 使用二分搜索算法搜索指定值的指定数组的范围。
static int binarySearch(long[] a, long key) 使用二进制搜索算法搜索指定数组的指定数组。
static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key) 使用二进制搜索算法搜索指定对象的指定数组的范围。
static int binarySearch(Object[] a, Object key) 使用二叉搜索算法搜索指定对象的指定数组。
static int binarySearch(short[] a, int fromIndex, int toIndex, short key) 使用二进制搜索算法搜索指定值的指定数组的短整型范围。
static int binarySearch(short[] a, short key) 使用二进制搜索算法搜索指定值的指定数组的指定值。
static int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
使用二进制搜索算法搜索指定对象的指定数组的范围。
static int binarySearch(T[] a, T key, Comparator<? super T> c)
使用二叉搜索算法搜索指定对象的指定数组。
static boolean[] copyOf(boolean[] original, int newLength)
使用 false （如有必要）复制指定的数组，截断或填充，以使副本具有指定的长度。
static byte[] copyOf(byte[] original, int newLength)
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
static char[] copyOf(char[] original, int newLength)
复制指定的数组，截断或填充空字符（如有必要），以便复制具有指定的长度。
static double[] copyOf(double[] original, int newLength)
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
static float[] copyOf(float[] original, int newLength)
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
static int[] copyOf(int[] original, int newLength)
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
static long[] copyOf(long[] original, int newLength)
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
static short[] copyOf(short[] original, int newLength)
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
static T[] copyOf(T[] original, int newLength)
复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。
static <T,U> T[] copyOf(U[] original, int newLength, 类<? extends T[]> newType)
复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。
static boolean[] copyOfRange(boolean[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static byte[] copyOfRange(byte[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static char[] copyOfRange(char[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static double[] copyOfRange(double[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static float[] copyOfRange(float[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static int[] copyOfRange(int[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static long[] copyOfRange(long[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static short[] copyOfRange(short[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static T[] copyOfRange(T[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
static <T,U> T[] copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)
将指定数组的指定范围复制到新数组中。
static boolean deepEquals(Object[] a1, Object[] a2)
如果两个指定的数组彼此 深度相等 ，则返回 true 。
static int deepHashCode(Object[] a)
根据指定数组的“深度内容”返回哈希码。
static String deepToString(Object[] a)
返回指定数组的“深度内容”的字符串表示形式。
static boolean equals(boolean[] a, boolean[] a2)
如果两个指定的布尔数组彼此 相等 ，则返回 true 。
static boolean equals(byte[] a, byte[] a2)
如果两个指定的字节数组彼此 相等 ，则返回 true 。
static boolean equals(char[] a, char[] a2)
如果两个指定的字符数组彼此 相等 ，则返回 true 。
static boolean equals(double[] a, double[] a2)
如果两个指定的双精度数组彼此 相等 ，则返回 true 。
static boolean equals(float[] a, float[] a2)
如果两个指定的浮动数组彼此 相等 ，则返回 true 。
static boolean equals(int[] a, int[] a2)
如果两个指定的int数组彼此 相等 ，则返回 true 。
static boolean equals(long[] a, long[] a2)
如果两个指定的longs数组彼此 相等 ，则返回 true 。
static boolean equals(Object[] a, Object[] a2)
如果两个指定的对象数组彼此 相等 ，则返回 true 。
static boolean equals(short[] a, short[] a2)
如果两个指定的短裤阵列彼此 相等 ，则返回 true 。
static void fill(boolean[] a, boolean val)
将指定的布尔值分配给指定的布尔数组的每个元素。
static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
将指定的布尔值分配给指定数组布尔值的指定范围的每个元素。
static void fill(byte[] a, byte val)
将指定的字节值分配给指定字节数组的每个元素。
static void fill(byte[] a, int fromIndex, int toIndex, byte val)
将指定的字节值分配给指定字节数组的指定范围的每个元素。
static void fill(char[] a, char val)
将指定的char值分配给指定的char数组的每个元素。
static void fill(char[] a, int fromIndex, int toIndex, char val)
将指定的char值分配给指定的char数组的指定范围的每个元素。
static void fill(double[] a, double val)
将指定的double值分配给指定的双精度数组的每个元素。
static void fill(double[] a, int fromIndex, int toIndex, double val)
将指定的double值分配给指定的双精度数组范围的每个元素。
static void fill(float[] a, float val)
将指定的float值分配给指定的浮点数组的每个元素。
static void fill(float[] a, int fromIndex, int toIndex, float val)
将指定的浮点值分配给指定的浮点数组的指定范围的每个元素。
static void fill(int[] a, int val)
将指定的int值分配给指定的int数组的每个元素。
static void fill(int[] a, int fromIndex, int toIndex, int val)
将指定的int值分配给指定的int数组的指定范围的每个元素。
static void fill(long[] a, int fromIndex, int toIndex, long val)
将指定的long值分配给指定的longs数组的指定范围的每个元素。
static void fill(long[] a, long val)
将指定的long值分配给指定的longs数组的每个元素。
static void fill(Object[] a, int fromIndex, int toIndex, Object val)
将指定的对象引用分配给指定的对象数组的指定范围的每个元素。
static void fill(Object[] a, Object val)
将指定的对象引用分配给指定的对象数组的每个元素。
static void fill(short[] a, int fromIndex, int toIndex, short val)
将指定的短值分配给指定的短裤数组的指定范围的每个元素。
static void fill(short[] a, short val)
将指定的短值分配给指定的短裤数组的每个元素。
static int hashCode(boolean[] a)
根据指定数组的内容返回哈希码。
static int hashCode(byte[] a)
根据指定数组的内容返回哈希码。
static int hashCode(char[] a)
根据指定数组的内容返回哈希码。
static int hashCode(double[] a)
根据指定数组的内容返回哈希码。
static int hashCode(float[] a)
根据指定数组的内容返回哈希码。
static int hashCode(int[] a)
根据指定数组的内容返回哈希码。
static int hashCode(long[] a)
根据指定数组的内容返回哈希码。
static int hashCode(Object[] a)
根据指定数组的内容返回哈希码。
static int hashCode(short[] a)
根据指定数组的内容返回哈希码。
static void parallelPrefix(double[] array, DoubleBinaryOperator op)
使用提供的功能，并行地计算给定阵列的每个元素。
static void parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)
对于数组的给定子范围执行 parallelPrefix(double[], DoubleBinaryOperator) 。
static void parallelPrefix(int[] array, IntBinaryOperator op)
使用提供的功能，并行地计算给定阵列的每个元素。
static void parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)
对于数组的给定子范围执行 parallelPrefix(int[], IntBinaryOperator) 。
static void parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)
对于数组的给定子范围执行 parallelPrefix(long[], LongBinaryOperator) 。
static void parallelPrefix(long[] array, LongBinaryOperator op)
使用提供的功能，并行地计算给定阵列的每个元素。
static void parallelPrefix(T[] array, BinaryOperator op)
使用提供的功能，并行地计算给定阵列的每个元素。
static void parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator op)
对于数组的给定子范围执行 parallelPrefix(Object[], BinaryOperator) 。
static void parallelSetAll(double[] array, IntToDoubleFunction generator)
使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
static void parallelSetAll(int[] array, IntUnaryOperator generator)
使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
static void parallelSetAll(long[] array, IntToLongFunction generator)
使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
static void parallelSetAll(T[] array, IntFunction<? extends T> generator)
使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
static void parallelSort(byte[] a)
按照数字顺序排列指定的数组。
static void parallelSort(byte[] a, int fromIndex, int toIndex)
按照数字顺序排列数组的指定范围。
static void parallelSort(char[] a)
按照数字顺序排列指定的数组。
static void parallelSort(char[] a, int fromIndex, int toIndex)
按照数字顺序排列数组的指定范围。
static void parallelSort(double[] a)
按照数字顺序排列指定的数组。
static void parallelSort(double[] a, int fromIndex, int toIndex)
按照数字顺序排列数组的指定范围。
static void parallelSort(float[] a)
按照数字顺序排列指定的数组。
static void parallelSort(float[] a, int fromIndex, int toIndex)
按照数字顺序排列数组的指定范围。
static void parallelSort(int[] a)
按照数字顺序排列指定的数组。
static void parallelSort(int[] a, int fromIndex, int toIndex)
按照数字顺序排列数组的指定范围。
static void parallelSort(long[] a)
按照数字顺序排列指定的数组。
static void parallelSort(long[] a, int fromIndex, int toIndex)
按照数字顺序排列数组的指定范围。
static void parallelSort(short[] a)
按照数字顺序排列指定的数组。
static void parallelSort(short[] a, int fromIndex, int toIndex)
按照数字顺序排列数组的指定范围。
static <T extends Comparable<? super T>>
void parallelSort(T[] a)
对指定对象升序排列的阵列，根据natural ordering的元素。
static void parallelSort(T[] a, Comparator<? super T> cmp)
根据指定的比较器引发的顺序对指定的对象数组进行排序。
static <T extends Comparable<? super T>>
void parallelSort(T[] a, int fromIndex, int toIndex)
对指定对象升序排列的数组的指定范围内，根据natural ordering的元素。
static void parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)
根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。
static void setAll(double[] array, IntToDoubleFunction generator)
使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
static void setAll(int[] array, IntUnaryOperator generator)
使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
static void setAll(long[] array, IntToLongFunction generator)
使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
static void setAll(T[] array, IntFunction<? extends T> generator)
使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
static void sort(byte[] a)
按照数字顺序排列指定的数组。
static void sort(byte[] a, int fromIndex, int toIndex)
按升序排列数组的指定范围。
static void sort(char[] a)
按照数字顺序排列指定的数组。
static void sort(char[] a, int fromIndex, int toIndex)
按升序排列数组的指定范围。
static void sort(double[] a)
按照数字顺序排列指定的数组。
static void sort(double[] a, int fromIndex, int toIndex)
按升序排列数组的指定范围。
static void sort(float[] a)
按照数字顺序排列指定的数组。
static void sort(float[] a, int fromIndex, int toIndex)
按升序排列数组的指定范围。
static void sort(int[] a)
按照数字顺序排列指定的数组。
static void sort(int[] a, int fromIndex, int toIndex)
按升序排列数组的指定范围。
static void sort(long[] a)
按照数字顺序排列指定的数组。
static void sort(long[] a, int fromIndex, int toIndex)
按升序排列数组的指定范围。
static void sort(Object[] a)
对指定对象升序排列的阵列，根据natural ordering的元素。
static void sort(Object[] a, int fromIndex, int toIndex)
对指定对象升序排列的数组的指定范围内，根据natural ordering的元素。
static void sort(short[] a)
按照数字顺序排列指定的数组。
static void sort(short[] a, int fromIndex, int toIndex)
按升序排列数组的指定范围。
static void sort(T[] a, Comparator<? super T> c)
根据指定的比较器引发的顺序对指定的对象数组进行排序。
static void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。
static Spliterator.OfDouble spliterator(double[] array)
返回Spliterator.OfDouble覆盖所有指定数组。
static Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive)
返回Spliterator.OfDouble覆盖指定数组的指定范围内。
static Spliterator.OfInt spliterator(int[] array)
返回Spliterator.OfInt覆盖所有指定数组。
static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive)
返回Spliterator.OfInt覆盖指定数组的指定范围内。
static Spliterator.OfLong spliterator(long[] array)
返回Spliterator.OfLong覆盖所有指定数组。
static Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive)
返回Spliterator.OfLong覆盖指定数组的指定范围内。
static Spliterator spliterator(T[] array)
返回Spliterator覆盖所有指定数组。
static Spliterator spliterator(T[] array, int startInclusive, int endExclusive)
返回Spliterator覆盖指定数组的指定范围内。
static DoubleStream stream(double[] array)
返回顺序DoubleStream与指定的数组作为源。
static DoubleStream stream(double[] array, int startInclusive, int endExclusive)
返回顺序DoubleStream与指定的数组作为源的指定范围。
static IntStream stream(int[] array)
返回顺序IntStream与指定的数组作为源。
static IntStream stream(int[] array, int startInclusive, int endExclusive)
返回顺序IntStream与指定的数组作为源的指定范围。
static LongStream stream(long[] array)
返回顺序LongStream与指定的数组作为源。
static LongStream stream(long[] array, int startInclusive, int endExclusive)
返回顺序LongStream与指定的数组作为源的指定范围。
static Stream stream(T[] array)
返回顺序Stream与指定的数组作为源。
static Stream stream(T[] array, int startInclusive, int endExclusive)
返回顺序Stream与指定的数组作为源的指定范围。
static String toString(boolean[] a)
返回指定数组的内容的字符串表示形式。
static String toString(byte[] a)
返回指定数组的内容的字符串表示形式。
static String toString(char[] a)
返回指定数组的内容的字符串表示形式。
static String toString(double[] a)
返回指定数组的内容的字符串表示形式。
static String toString(float[] a)
返回指定数组的内容的字符串表示形式。
static String toString(int[] a)
返回指定数组的内容的字符串表示形式。
static String toString(long[] a)
返回指定数组的内容的字符串表示形式。
static String toString(Object[] a)
返回指定数组的内容的字符串表示形式。
static String toString(short[] a)
返回指定数组的内容的字符串表示形式。

Arrays类只要方法学习

二分法查询的方法：

public static int binarySearch(int[] a,int key)//方法头信息
//作用:在指定的数组中查找指定的值,如果该值存在于这个数组中,则返回该值的索引,如果存在多个该值,返回的是哪个值的索引是不正确的;如果数组中没有指定的值则返回负数;如果传递的数组为null，则会抛出空指针异常;
//参数:int[] a:要查询的数组;int key:要查询的值;
//返回值:返回索引或负数;
//该方法适用于除了boolean以外的基本数据类型及所有的引用类型;
//使用该方法数组必须先排序  否则返回的结果是不确定的


/**
*null 在内存中是特殊的存在
*所有的引用数据类型默认是null
*所有的引用数据类型变量可以复制为null
*都是null是一个地址，都是不代表是一个对象
*使用该变量通常会收到 空指针异常
*/

.

public static int binarySearch(int[] a,int fromIndex,int toIndex,int key)//方法头信息
//作用:可以在数组中指定一个范围去查找值;
//参数:fromIndex开始索引,范围包括开始索引;toIndex结束索引,范围不包括结束索引;
//其余同上方法;

在这里插入图片描述
**二分查找发的前提是：**数组是有序的；如果数组无序，那么排序的结果是不确定的；
在这里插入图片描述
源码分析：

//Like public version,but without range checks.
private static int binarySerch0(int[] a,int fromIndex,int toIndex,int key){
	int low = fromIndex; //包含开始索引
	int high = toIndex - 1; //不包含结束索引
	while(low <= high){
		int mid = (low + high) >>> 1; //寻找中间点索引    >>>  无符号右移，下面有解析
		int midVal = a[mid]; //记住中间点的元素值

		if(midVal < key)
			low = mid + 1;
		else if (midVal > key)
			high = mid - 1;
		else
			return mid;  //key found  中间点就是要找的key
	}
	return -(low + 1); //key not fount.  做后返回的数
}

<< >> >>> 之间的区别：
<< : 左移运算符，num <<1,相当于num乘以2

:    右移运算符，num >>1,相当于num除以2

: 无符号右移，忽略符号位，空位都以0补齐，（计算机中数字以补码存储，首位为符号位）。

如：a = 00110111，则a>>2 = 00001101，b=11010011，则b>>2 = 11110100；

如：a = 00110111，则a>>>2 = 00001101，b=11010011，则b>>>2 = 00110100。
摘自：作者：leo_qiu_s 原文：https://blog.csdn.net/qiudechao1/article/details/80671213

public static int[] copy(itn[] original,int newLength)
//作用：把参数数组original赋值一份，生成一个新数组返回；新数组的长度可以大于、等于或小于参数数组长度；
//大于：把参数数组的值拷贝过去，其余是默认值；等于：吧参数数组的值拷贝过去刚刚好；小于：只把新数组能够存储的值拷贝过去，其余值丢弃；

案例：我们使用数组存储了50名学生的考试信息 , 今天又增加了三名同学 , 请扩大存储介质 , 足以存储53名学生信息

public static void addScore(){
		int[] score = new int[50];
		for(int i = 0; i < score.length; i++)
			score[i] = (int)(Math.random());
		System.out.println(Arrays.toString(score));
		
		int[] sc= Arrays.copyOf(score,score.length + 3);
		
		System.out.println(Arrays.toString(sc));
	}

运行结果：
在这里插入图片描述

public static int[] copyOdRange(int[] original,int from,int to)
//作用:吧参数数组的某一部分值拷贝过去，生成新数组返回；
//但凡接收两个索引，且一个是其实索引，一个是结束索引，你们往往包含起始索引，并不包含结束索引

Java基本和引用数据类型存储的不同

"=="在针对引用数据类型并不是百分之百使用；

"=="关系运算符，判断两个变量是否相等，相等返回TRUE，繁殖返回FALSE；

//java基本和引用数据类型存储的不同：
		int[] its = {200,12,70,35,60,80,90,100,150,150};
		int[] it = {200,12,70,35,60,80,90,100,150,150};
		System.out.println(its == it);//false 比较的是展中的值，栈中存的数组地址

在这里插入图片描述
正常情况下，数组长度和值完全相等，我们就认为这两个数组是相等的，即用equals方法实现数组比较：

main方法的语句：
//java基本和引用数据类型存储的不同：
		int[] its = {200,12,70,35,60,80,90,100,150,150};
		int[] it = {200,12,70,35,60,80,90,100,150,150};
		System.out.println(equals(its,it));//false 比较的是展中的值，栈中存的数组地址

equals方法：
/**
	 * Java基本和引用数据类型存储的不同：
	 * "=="关系运算符，判断两个变量是否相等，相等返回TRUE，繁殖返回false
	 * equals方法
	 */
	private static boolean equals(int[] a, int[] a2) {
		// TODO Auto-generated method stub
		if(a == a2)    //地址相等
			return true;
		if(a == null || a2 == null)  //判断是否为null
			return false;            //防御试编程
		
		int length = a.length;  //记录长度，为了提高效率
		if(a2.length != length)
			return false;   //长度不同
		
		for(int i = 0; i < length; i++)
			if(a[i] != a2[i])       //判断每一个索引上的值
				return false;       //只要一个不相等 就return false
		
		return true;
	}

在这里插入图片描述

数组排序方法：

public static void sort(int[] a)  //数组升序排序的方法;

把参数数组的值拼接成字符串的方法：

public static String toString(int[] a) //把参数转成字符串描述，并返回该字符串;
堆栈内存分析

引用数据类型存储有两个空间：栈空间、堆空间；
堆里面存的是引用数据类型本身，栈里面存的是引用数据类型的地址；
基本数据类型存储有一个空间：栈空间；
Java中的值传递：严格来说java中只有值传递 , 引用数据类型传递是地址,也叫引用 , 其实传递也是值 , 只不过值就是地址而已;
在这里插入图片描述

、

方法的可变参数

定义：当方法的参数定义成 xx类型…名字 时，这就是一个可变参数；

特性：

1.方法的可变参数只能定义形参列表的最后；形参列表可以定义多个形参，多个形参之间用逗号隔开；可变参数只能位于最后，所以一个方法最多只能定义一个可变参数；
2.可变参数主要是"变",这里的变强调的是调用时的变化;调用时可以传递0个1个或多个该类型的参数，也可以直接传递一个该类型的数组；当方法被调用时，实参传递的可变参数实际上是该类型的数组类型，即多个参数被装入到数组里，然后赋值给可变参数；
切记：不可以传递了1个或多个实参之后再传递给类型数组；

public static void show(int[] ...i){
    System.out.println(i);
    System.out.println(i.length);
    System.out.println(Arrays.toString(i));

3.如果普通参数方法和可变参数方法都满足调用条件，则优先使用普通参数方法；

4.可变参数基本等同于数组参数 (无法重载 , 如下定义会报错 ), 但是调用范围更广 ;

应用场景：基本上所有用数组做参数的方法 都可以把数组参数替换成可变参数，可变参数更强大

多维数组

思维导图：
在这里插入图片描述
以为数组存储的是非数组类型； int[] i String[] s
二维数组有别于以为数组的地方是，二维数组存储的是一维数组；
二维数组的构成都是同一类型 同一名字 不同索引号的一位数组数据的组合；
一维数组的类型是 类型[] ; int[] int; ,int ,int
二维数组类型 类型[][]; itn[][] int[] ,int[] , int[]
多维数组的内存结构：
在这里插入图片描述

二维数组的声明初始化：

格式1：静态初始化

语法格式：

类型[][] 数组名={{},{},{}...};//{}里面可以放0个1个或多个一维数组;
//声明和初始化必须在同一行，数组中存储的值都是自定义的;

代码示例：

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

二维静态初始化的内存分析图：
在这里插入图片描述

动态初始化

语法格式：

类型[][] 名字;
名字 = new 类型[length1][length2];//声明初始化可在一行也可不在一行，存储的值都是默认值;其中length1是必须的，length2不是必须的;

代码示例：

int[][] array;
array = new int[2][];

二维数组动态初始化内存分析图：
####在这里插入图片描述

格式3：动静结合初始化

语法格式：

类型[][] 名字;
名字 = new 类型[][]{{},{},{}...};//{}里面可以放0个1个或多个一维数组;

代码示例：

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

在这里插入图片描述

二维数组的使用：

元素访问
一维数组：
一维数组名字[索引] 即可访问数组存储的元素; array[0]
二维数组访问一维数组:
二维数组名字[索引] 即可得到二维数组中存储的一维数组; arrays[0]
二维数组访问以为数组中的元素:arrays[0][0]
首先要确定要访问哪一个一维数组:二维数组名字[索引][索引];
确定一维数组之后按照一维数组的方法获得:二维数组名字[索引][索引];

二维数组的遍历:

第一种方式:采用嵌套for循环的形式
代码示例:

 public static void main(String[] args) {
        //二位数组的遍历---采用嵌套for循环的形式
        int[][] its = new int[][] {{1},{1,2},{1,2,3}};
        for (int i = 0; i < its.length; i++){
            for (int j = 0; j < its[i].length; j++){
                System.out.print(its[i][j] + " ");
            }
            System.out.println();
        }
    }

第二种方式:采用foreach的形式
代码示例:

//二维数组的遍历--采用foreach的形式
        int[][] its1 = new int[][]{{2},{2,3},{3,4,5}};
        for (int[] it:its1) {
            for (int i:it) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
Amanda_jx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Arrays工具类用法详解
08-26
"Java Arrays工具类用法详解" Java Arrays工具类是Java语言中的一种工具类，主要提供了数组元素的修改、复制、排序等操作。该类中的方法均为static修饰的，可以直接通过Arrays.xxx(xxx)的形式调用方法。 1. Arrays...
Arrays工具类常用方法
12-22
C语言自学完备手册(33篇) Android多分辨率适配框架 JavaWeb核心技术系列教程 ...在Java API中提供了操作数组的工具类 java.util.Arrays，例如：排序，查找，复制，数组转集合，数组转字符串等常见操
Arrays工具类的常见方法总结
m0_68041576的博客
02-17 2300
方法通过传入参数原始数组和想要创建的新数组的长度，返回一个int类型的数组，创建一个新的数组int[ ] copy:长度为newLength,用于存放复制过来的元素，然后通过System.arraycopy( )方法,将原数组中的元素复制到copy数组中。方法通过传入参数目标数组和需要查找的元素，返回binarySearch0（）方法的四个参数:a:要搜索的数组 0：要搜索的起始下标 a.length：要搜索的结束下标最后一个元素的下标为a.length-1 key:要搜索的值。
Java基础06(数组进阶 Arrays工具类)
最新发布
qq_52897007的博客
04-28 1172
第一种方式是通过for循环：因为数组的每个元素都可以通过索引来访问，因此，使用标准的for循环可以完成一个数组的遍历：初始条件为i=0，因为索引总是从0开始，继续循环的条件为i < ns.length，因为当i = ns.length时，i已经超出了索引范围（索引范围是0 ~ ns.length-1），每次循环后，i++实现索引递增。
java Arrays工具类的使用
超级大洋葱的博客
01-10 230
import java.util.Arrays; /** Arrays工具类的使用 */ public class ArraysTest { public static void main(String[] args) { int[] n = {1,3,2,45,5,-1}; int[] n2 = {1,2,3,5,4}; //boolean equals(int[] a,int[] b) : 比较两个数组是否相等。（数组的内容，个数，顺序） boolean e.
数组的工具，Arrays工具类
Best_jiangX的博客
03-19 1129
Arrays工具类的常用方法，混个眼熟，别等用的时候找不到！！！
Arrays 工具类
一个程序员的成长之路。。。
12-17 7680
JDK 提供了一个工具类专门用来操作数组的工具类，即 Arrays，该 Arrays 工具类提供了大量的静态方法排序Arrays 工具类中的静态方法 sort() 可以对数组进行排序。Example.java 示例代码：import java.util.*;public class Example { public static void main(String[] args){
Arrays工具类的常用方法总结
weixin_65829479的博客
03-05 920
用于定义数组中元素的排序顺序。：创建一个新的int数组copy,其长度为newLength,这个数组将用于存储原始数组的副本，original,0指定原始数组original和从该数组的索引0开始复制，copy,0指定目标数组copy和从该数组的索引0开始写入数据，math.min(original.length,newLength)计算要复制的元素数量。：计算新数组的长度，to和from索引之间的元素数量，如果新长度小于0，则from索引大于to索引，不符合方法的使用规则，因此抛出异常。
Arrays工具类的使用
qq_56457318的博客
04-09 619
使用Arrays工具类的原因 我们在操作数组（比 如排序和搜索）时，操作编写代码太过于多，这个工具类方便的解决了这个问题。 java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比 如排序和搜索）的各种方法。 举一些常用的方法： 我们来看一下这些方法底层内部类是如何实现的： 1.boolean equals(int[] a,int[] b) 判断两个数组是否相等。 2 .String toString(int[] a) 输出数组信息。 3 void fil..
Java基础——Arrays工具类详解
weixin_70890083的博客
08-10 1327
JDK 中提供了一个专门用于操作数组的工具类，即Arrays 类，位于java.util 包中。该类提供了一些列方法来操作数组，如排序、复制、比较、填充等，用户直接调用这些方法即可不需要自己编码实现，降低了开发难度。java.util.Arrays 是一个与数组相关的工具类，里面提供了大量静态方法，用来事项数组常见的操作。
java的Arrays工具类实战
08-31
Java的`java.util.Arrays`工具类是Java标准库中一个非常实用的类，它提供了大量静态方法来处理各种类型的数组，包括整型、浮点型、字符型、对象型等。这个工具类使得操作数组变得更为简单和高效，避免了手动实现数组...
java Arrays工具类实例详解
08-29
Java Arrays工具类实例详解 Java Arrays工具类是Java语言中的一种常用的工具类，提供了许多实用的方法来操作数组。下面是对Java Arrays工具类实例详解的相关知识点： 排序方法 Java Arrays工具类提供了多种排序...
第03章 方法与数组 11 Arrays工具类
09-13
在Java编程语言中，Arrays工具类是Java标准库（java.util包）的一部分，它提供了大量静态方法，用于操作和处理数组。本章我们将深入探讨Arrays工具类的核心功能和使用方式，帮助你更好地理解和运用这个强大的工具。 ...
Java语言编写输出九九乘法表
热门推荐
Amanda的博客
03-11 1万+
Java语言编写九九乘法表 用Java打印乘法表 ···`package day03; public class weijiaxin { public static void main(String[] args) { //使用循环打印99乘法表 System.out.println(“使用循环打印99乘法表”); for (int i = 1; i &amp;amp;lt;= 9; i++) { System....
海滩上有一堆桃子，五只猴子来分。 第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。 第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走
Amanda的博客
04-14 1万+
海滩上有一堆桃子，五只猴子来分。 第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。 第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份， 第三、第四、第五只猴子都是这样做的， 问海滩上原来最少有多少个桃子？ 代码： public class peach { public static void main(String[] a...
输入成绩，判断成绩等级&If&Switch
Amanda的博客
03-22 9392
输入成绩，判断成绩等级 import java.util.Scanner; public class ScoreIf { public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入成绩"); int score = sc.nextInt();...
javaarrays工具类
06-02
Java提供了许多内置的数组工具类，例如： 1. Arrays类：提供了对数组进行排序、查找、比较等操作的方法； 2. System类：提供了对数组进行复制、填充等操作的方法； 3. Collections类：提供了对List、Set等集合类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值