一维数组
一、基本概念
数组是编程语言中最常见的一种数据结构，可以用它来存储一个元素个数固定且元素类型相同的有序集，每个数组元素存放一个数据，通常可通过数组元素的索引来访问数组元素，包括为数组元素赋值和取出数组元素的值。
特点：个数固定，参数数据类型相同，有序集
数组也是一种数据类型，它本身是一种引用数据类型。像int、double、char等等这些属于基本数据类型，但int[ ] 就是一种引用数据类型了；除了数组，类、接口也是引用数据类型。
二、声明及使用
1)声明创建
先声明
dataType[ ] arrayName;
数据类型[ ] 数组引用变量；
再创建
arrayName = new dataType[arraySize];
可以用一条语句完成：
dataType[] arrayName = new dataType[arraySize];
2）访问数组元素
数组里面每个元素都可以通过下面语法表示，下标(索引)是从0开始的，所以它的范围是0~arrayName.length-1。
arrayName[index];
(数组引用变量[下标];)
三、初始化
注意：数组使用前必须初始化。
1）动态初始化
特点：只告知数组需要几个存储空间，但是并未决定要存哪些值，由系统为每个元素指定初始值。
arrayName = new type[length];
2）静态初始化
特点：初始化数组和给数组赋值同时完成，在开辟数组的空间时依据已给定的元素个数来开辟相应的空间数。
/*语法结构*/
//第一种： elementType[] arrayName = new elementType[]{value0,value1,value2,...,valuek}; //第二种：更简捷 elementType[] arrayName={value0,value1,value2,...,valuek};
//(元素类型[] 数组引用变量={值1,值2,...,值k};
/*示例*/
public class ArrayDemo { public static void main(String[] args) { //一条语句声明创建 float[] scores = new float[100]; System.out.println(scores[1]); scores[2] =86; //索引从0开始 System.out.println(scores[2]); //System.out.println(scores[100]); //java.lang.ArrayIndexOutOfBoundsException数组越界异常 //先声明，再创建 // String[] name; // name = new String[100]; // //数组使用前需要进行初始化 String[] name = new String[12]; //动态初始化：只需要告知存储空间，不用赋值 String[] sing = new String[] {"aq","12sw","qswde"}; //静态初始化：声明之后要赋值 System.out.println(name[5]); System.out.println(sing.length); } }
四、数组遍历
数组的元素类型和数组的大小都是确定的，所以当处理数组元素的时候，通常使用基本循环或者foreach循环
数组大小：arrayName.length
如：for ( int i = 0 ; i < candyArray.length ; i ++){
System.out.print(candyArray[i]);
}
/* * 示例：输出数组及求和 * 1、打印数组 * 2、求所有元素之和 * @author longhj */ package edu.study.array.practice_1031; import java.util.Arrays; public class PrintAndSumArray { //主方法 public static void main(String[] args) { int[] number = {8,4,2,1,23,344,12}; System.out.println("打印数组："); printArray(number); System.out.printf("数组所有元素之和为：sum = %d ",sum(number)); } /** * 打印数组（三种方式）即遍历数组 * @param list int型数组list */ public static void printArray(int[] list) { //方式一：利用for循环 System.out.print("["); for(int i = 0 ;i < list.length;i++) { System.out.print(list[i]+(i == list.length - 1 ? "]\r\n" : ", ")); } //利用System.array类 System.out.println(Arrays.toString(list)); //foreach循环输出 for(int a:list) System.out.print(a + " "); System.out.println(); } /** * 求所有数组元素的和 * @param list 数组 * @return sum 累加和 */ public static int sum(int[] list) { int sum = 0; for(int i = 0 ;i < list.length ; i++) { sum +=list[i]; } return sum; } }
foreach循环：比for循环简便，不使用下标变量就可以顺序的遍历整个数组
//语法结构
for(elementType element : arrayName){
//Process the element
}
//如：
for(double e : list){ System.out.println(e);//解释：对list中每个元素e进行以下操作。注意，变量e必须声明为与list中元素相同的数据类型。 }
五、对数组的操作
1）数组的处理
通过一些例子来更好的理解
//import java.util.Arrays; import java.util.Scanner; public class ArrayTest { //主函数 public static void main(String[] args) { int[] number = {12,23,45,67};//初始化数组 inputInitArray(); randomInitArray(); //调用找出最大值方法 System.out.println(getMax(number)); //调用生肖方法 System.out.println(zodiac(2023)); } /** * 1）使用输入值初始化数组：循环使用用户输入的数值初始化数组。 */ public static void inputInitArray() { //声明创建了大小为10的double型数组 double[] list = new double[5]; Scanner input = new Scanner(System.in); System.out.println("请输入" + list.length + "个值："); for(int i = 0; i < list.length; i++) list[i] = input.nextDouble(); input.close(); printArray(list); } /** * 2）打印数组中的每个元素 * @param arr double型数组 */ public static void printArray(double[] arr) { //第一种方式：使用for循环 System.out.print("["); for(int i = 0; i < arr.length; i++) System.out.print(arr[i] + (i == arr.length - 1 ? "]\r\n" : ", ")); //第二种形式：使用Arrays工具类完成打印 //System.out.println(Arrays.toString(arr)); } /** * 3）使用随机数初始化数组 */ public static void randomInitArray() { double[] list = new double[5]; for(int i = 0; i < list.length; i++) { list[i] = Math.random() * 100; } printArray(list); }/** * 4）找出最大值 * @param list * @return */ public static int getMax(int[] list) { int number = list[0]; for(int i = 1 ; i < list.length ; i++) { if(number < list[i]) number = list[i]; } System.out.println("最大值为："); return number; } /** * 5）返回数组中最大元素第一次出现的索引下标 * @param list * @return index 索引下标 */ public static int getIndextMax(int[] list) { int max = list[0]; int index = 0; for(int i = 1 ; i < list.length ; i++) { if(max < list[i]) { max = list[i]; index = i; } } return index; } /** * 6）打印生肖 * @param year * @return */ public static String zodiac(int year) { String[] years = {"猴","鸡","狗","猪","鼠","牛","虎","兔","龙","蛇","马","羊"}; System.out.println(year + "年的生肖为:" + years[year % 12]); return "1"; }
}
示例：打乱顺序
/* * 需求：将数组中的数据打乱顺序 */ import java.util.Arrays; public class Work5 { public static void main(String[] args) { int [] list = randomInitArray(); System.out.println("打乱前:" + Arrays.toString(list)); disrupt(list); System.out.println("打乱后:" +Arrays.toString(list) ); } /** * 生成随机数组 * */ public static int[] randomInitArray() { int[] list = new int[10]; for(int i = 0; i < list.length; i++) { list[i] =(int)( Math.random() * 100); } return list; } /** * 打乱顺序 * @param list */ public static void disrupt(int[] list) { for(int i = 0 ; i<list.length ; i++) { int index = (int)(Math.random()*list.length); int temp = list[i]; list[i] = list[index]; list[index] = temp; } } }
示例：给定两个数组，打印它们的共同元素
/* * 需求：打印两个有序数组中的共同元素 * */ import java.util.Arrays; public class Work { public static void main(String[] args) { int[] list1 = {3,7,5,11,12,9}; int[] list2 = {11,4,5,3}; compareArray(list1,list2); } public static void compareArray(int[] list1,int[] list2) { Arrays.sort(list1); Arrays.sort(list2); for(int i = 0;i<list1.length;i++) { for(int j=0;j<list2.length;j++) { if(list1[i]==list2[j]) { System.out.print(list1[i]+" "); } } } } }
2）数组的复制
在Java中，可以使用复制语句复制基本数据类型的变量，但不能复制数组。将一个数组变量赋值给另一个数组变量，实际上是将一个数组的引用赋值给另一个变量，使两个变量都指向相同的内存地址。
1、使用循环语句逐个地复制数组的元素。
int[] sourceArray = {1,5,7,11,12,-20};
int[] targetArray = new int[sourceArray.length];
for(int i = 0; i < sourceArray.length; i++)
targetArray[i] = sourceArray[i];
System.out.println(Arrays.toString(sourceArray));
System.out.println(Arrays.toString(targetArray));
2、使用System类中的静态方法arraycopy。
语法：System.arraycopy(sourceArray,srcPos,targetArray,tarPos,length);
其中，参数srcPos和tarPos分别表示在源数组sourceArray和目标数组targetArray中的起始位置，从sourceArray复制到targetArray中的元素个数由参数length指定。
System.arraycopy(sourceArray,0,targetArray,0,sourceArray.length);
3、使用clone方法复制数组。
int [] array3 = sourceArray.clone(); System.out.println(Arrays.toString(array3));
3）数组的传递
Java使用按值传递的方式将实参传递给方法。
- 对于基本数据类型参数，传递的是实参的值。
- 对于数组类型参数，参数值是数组的引用，给方法传递的这个引用。
示例1：
/** * 从方法返回一个数组（反转后的数组） * @param list 源数组 * @return 反转后的数组 */
//将数组传递给方法；从方法中返回数组
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for(int i = 0,j = result.length - 1; i < list.length; i++,j--)
result[j] = list[i]; return result;
}
示例2：
/*随机生成100个小写字母并将其放入到一个字符数组中， 对该数组中每个字母出现的次数进行统计。*/ package edu.study.array; public class StatisticsLetterCount { public static void main(String[] args) { //创建一个大小为100的字符数组,存入随机小写字母 char[] letters = new char[100]; for(int i=0;i<letters.length ; i++) { letters[i]=randomLowerLetter(); } // int[] times = new int[26]; for (char letter : letters) { times[letter - 'a']++; } for(int i = 0;i<times.length ;i++) { System.out.println((char)('a'+i)+":"+times[i]); } } /** * 随机生成的小写字母 * @return */ public static char randomLowerLetter() { return (char)('a' + Math.random() * ('z' - 'a')); } }
4）数组的排序
1、选择排序
原理：首先找到数组中最小的数，然后将它和第一个元素进行交换；在剩下的数中找到最小数，然后将它和第二个元素进行交换；依次类推，直到数列中只剩下一个元素
public static void selectionSort(int[] array) { for(int i = 0; i < array.length - 1; i++) { int currentMin = array[i]; int currentMinIndex = i; for(int j = i + 1; j < array.length; j++) { if(currentMin > array[j]) { currentMin = array[j]; currentMinIndex = j; } } if(currentMinIndex != i) { array[currentMinIndex] = array[i]; array[i] = currentMin; } } }
2、冒泡排序 （下沉排序）
原理：前一个跟后一个比较，大的往后移
public static int[] bubbleSorted(int[] array) { //i表示次数 for (int i = 0; i < array.length - 1; i++) { //j代表每次比较完后结束的位置 for (int j = 0; j < array.length - 1; j++) { if (array[j] > array[j + 1]) { int tmp=array[j]; array[j]=array[j+1]; array[j+1]=tmp; } } } return array; }
5）数组的查找
1、线性查找
原理：从数组的第一个元素依次比较，若相同，则返回该元素对应索引
public static int linearSearch(int key,int[] list) { for(int i = 0; i < list.length; i++) { if(list[i] == key) return i; } return -1; }
2、二分查找（折半查找）
原理：每次折半取中间数，如果关键字小于中间元素，只需要在数组的前一半进行查找；如果关键字大于中间元素，只需要在数组的后一半进行查找；相等，就返回mid
前提：数组是一个有序数组
public static int binarySearch(int key, int[] list) { //参数：要查找的数 ，数组 int low = 0; int high = list.length - 1; while(high >= low) {int mid = (low + high)/2; if(key < list[mid]) high = mid - 1; else if(key > list[mid]) low = mid + 1; else return mid; } return -low - 1; }
六、Arrays类（java.util.Arrays）
Arrays类包含各种各样的静态方法，用于实现数组的排序和查找、数组的比较和填充数组元素，以及返回数组的字符串表示。这些方法都有对所有基本类型的重载方法。
排序：sort ; parallelSort
二分查找：binarySearch
是否相等：equals
填充数组：fill
打印数组：toString
等等......
练习：给定一个整数数组，例如{6，4，7，2，5，8}和一个数字，例如10，请设计一个函数找出两个元素(或同一个元素加自身)，并且使这两个数的和为给定数字，并打印出来(提示:先进行数组排序)
package edu.study.array.practice_1031; import java.util.Arrays; import java.util.Scanner; public class Work7 { public static void main(String[] args) { int[] list = {6,4,7,2,5,8}; Arrays.sort(list); System.out.println("请输入一个数："); Scanner input = new Scanner(System.in); int num = input.nextInt(); input.close(); sumOfgetNumber(list,num); } /** * 判断两数之和或本身2倍是否等于number（遍历两遍） * @param list 数组 * @param number 要比较的数 * */ public static void sumOfgetNumber(int[] list,int number) { for(int i=0;i<list.length;i++) { for(int j =i+1;j<list.length;j++) { if(list[i]+list[j]==number) { System.out.println(list[i]+"+"+list[j]+"="+number); } } if(list[i]*2==number) { System.out.println(list[i]+"*"+2+"="+number); } } } }
浙公网安备 33010602011771号