数组的概念
数组时相同类型的数据的有序集合，描述的是相同类型的若干个数据，按一定的先后次序排列组合而成的集合。其中，每个数据被成为一个元素，每个元素可通过一个索引来访问。
数组的特点
- 长度是确定的：创建后大小不可改变
- 元素类型必须相同
- 数组类型可以是基本类型和引用类型
- 数组变量属于引用类型。可将数组看成对象，数组中每个元素相当于该对象的成员变量；Java中的对象在堆中存储，所以数组对象本身是存在堆中的。
数组的声明及初始化
数组的声明：
type[] arr_name;type arr_name [];
//基本类型
int [] arr;
int arr[];
//引用类型
Man[] mans;
Man mans[];
数组的初始化（3种）：
1. 静态初始化：
声明并设定数组的内容(分配空间并赋值）
//基本类型
int [] arr = new int [] {1,2,3};
//将new int[]省略：
int [] arr = {1,2,3};
//声明和初始化分开
int [] arr;
arr = new int [] {1,2,3}; //这里不能写成arr = {1,2,3};
//引用类型
Man [] mans = new Man [] {new Man(1,1),new Man(1,2)};
//省略new Man[]
Man [] mans = {new Man(1,1), new Man(1,2);
//声明和初始化分开
Man [] mans;
mans = new Man [] {new Man(1,1), new Man(1,2)};
2. 动态初始化：
只设定数组的长度（数组定义与为数组元素分配空间并赋值的操作分开进行）
//基本类型
int [] arr = new int [2];
arr[0] = 1;
arr[1] = 2;
//引用类型
Man [] mans = new Man [2]
mans[0] = new Man(1,3);
mans[1] = new Man(2,1);
3. 默认初始化：变量会被隐式的初始化
数组一经分配空间，其中的每个元素也按照与实例变量相同方式隐式初始化。
| 数据类型 | 默认值 |
|---|---|
| 整型 | 0 |
| 浮点型 | 0.0 |
| 字符型 | \u0000 |
| 布尔型 | false |
| 引用类型 | null |
分配数组空间
注意事项
注意：声明数组时并没有实例化任何对象，JVM不会分配内存空间；只有在实例化数组对象时，JVM才会分配内存空间，此时才与数组的长度有关，所以下列声明和初始化数组的形式是错误的。
int arr[4] = {1,2,3,4}; //错误
int c[];
c = new int[4] {1,2,3,4}; //错误
int a[] = new int []; //错误
int b[][] = new int[][]; //错误
int d[4][] = new int [4][4]; //错误
再写一次正确初始化的形式：
int arr[] = {1,2,3,4};
int c[] = new int [4];
c[0] = 1; c[1] = 2; c[2] = 3; c[3] = 4;
int d[];
d = new int []{1,2,3,4};
float []f[] = new float [6][6];
float [][]f = new float [6][];
数组的长度
数组长度可用数组名.length直接获得，数组下标的合法区间为[0,数组名.length - 1]。数组长度一旦确定后不可改：
//这里并不违背上面不可改的规定
int arr[] = new int [3];
arr = new int [5];
原因：数组内存是创建载堆区的
数组的常见操作
数组的遍历
//可运用于自己写的数组遍历中
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i]);
}
for_each循环
//循环输出数组或集合中所有元素
String [] str = {"aa", "bbb","cc"};
for(String temp: str) {
System.out.println(temp);
}
数组的复制
用System类中的static void arraycopy(object src, int srcpos, object des, int despos, int length)方法，可以将src数组中srcpos下标位置（从0开始计数）的数字赋值，参数length指定将src数组中多少个元素赋值给des数组的元素。
String [] str = {"aa","aae","eas"};
String [] str1 = new String [6];
//将str 复制到str1中
System.arraycopy(str, 0, str1, 0, str.length);
注意：复制时应该注意str1是否会超过数组的最大长度。（会产生溢出异常：ArrayIndexOutOfBoundsException
数组遍历打印输出
System.out.println(Arrays.toString(arr));
数组排序
基本类型
import java.util.Arrays;
public class Test{
public static void main(String [] args){
int [] arr = {9,1,4,2};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
自定义类型
需要对Comparable 接口的compareTo()函数进行重写。参考博文：[https://blog.csdn.net/guicaizhou/article/details/]
//按年龄升序排列
import java.util.Arrays;
public class Test{
public static void main(String [] args){
Man[] mans = {new Man(1, 21, "xx"), new Man(2,12,"ll"), new Man(3, 10,"xl");}
Arrays.sort(mans);
System.out.println(Arrays.toString(mans));
}
}
class Man implements Comparable{
int age; //定义年龄
int id; //定义编号
String name; //定义年龄
public Man(int id, int age,String name){
this.age = age;
this.id = id;
this.name = name;
}
public String toString(){
return this.name;
}
//重写Comparable中的compareTo方法
public int compareTo(Object o){
Man man = (Man) o; //强制类型转换
if(this.age < man.age){ //若自身的age小于传入的age
return -1; //返回-1
}else if(this.age > man.age){ //前面大于后面，则返回1并交换
return 1;
}else
return 0;
}
}
用二分查找法查找数组元素
public class Test{
public static void main(String [] aa){
//定义一个数组，用二分查找法找出对应的数字
double [] digits = {1.2, 1.3, 2.9, 0.1, 3.9, 2.1, 0.01};
printArray(digits);
//二分法前应排序
Arrays.sort(digits);
//用系统提供的方法打印输出
System.out.println(Arrays.toString(digits));
//用二分查找输出结果
System.out.println("该元素的索引为：" + Arrays.binarySearch(digits, 1.2));
}
//遍历打印输出
public static void printArray(double [] array){
for(double temp : array){
System.out.print(temp + " ");
}
}
}
多维数组
//二维数组
public class Test{
public static void main (String [] args){
int [][] arr = new int [4][];
arr[0] = new int [] {1,2,3};
arr[1] = new int [] {2,1};
arr[2] = new int [] {2,0};
System.out.println(arr[1][0]); //2
System.out.println(Arrays.toString(arr[0])); //[1,2,3]
/* 这里不能直接写System.out.println(arr);
* 因为这样写只是输出了arr的地址
*/
System.out.println(Arrays.toString(arr[1]));//[2,1]
System.out.println(Arrays.toString(arr[2]));//[2,0]
//输出数组长度
System.out.println(arr.length); //第一维数组长度
System.out.println(arr[2].length); //第二维数组长度
}
}
用数组存储表格数据
//用二维数组存储表格数据
public class Test{
public static void main (String [] args){
Object[][] arr = new Object [3][];
Object[] a1 = {10001,"cc",25,"大学讲师",2020-12-11};
Object[] a2 = {10222, "bb",21,"架构师",2020-11-11};
Object[] a3 = {10000,"aa",24,"软件开发工程师",2022-12-12};
arr[0] = a1;
arr[1] = a2;
arr[2] = a3;
System.out.println(Arrays.toString(arr[0]));
System.out.println(Arrays.toString(arr[1]));
System.out.println(Arrays.toString(arr[2]));
System.out.println(Arrays.toString(arr)); //不能用此输出所有
}
}
冒泡排序算法及其优化
public class Test{
public static void main(String [] args){
//定义一个数组
int [] arr = {1,4,3,2,8,5,9,6,7};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int [] array){
//冒泡排序法的优化
for(int i = 0; i < array.length - 1; i++){
//定义flag判断数组是否已经有序
boolean flag = true; //初始化为有序
for(int j = 0; j < array.length - 1 - i; j++){
//比较相邻两个数的大小,若左侧的数大于右侧，则交换
if(array[j] > array[j+1]){
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
//有交换，则证明此循环处于无序状态
flag = false;
}
}
if(flag) break; //有序 => 退出
}
}
}
数组编码题
1. 数组查找操作：
//基础型
public class Test{
public static void main(String [] args){
//数组查找操作
String [] str =
{"apple","pen","banana","watermelon","peach",
"test","great","main","string","static"
};
System.out.println("原数组为"+Arrays.toString(str));
//对元素进行排序
Arrays.sort(str);
System.out.println("排序后数组为"+Arrays.toString(str));
System.out.println("要找的单词在第" +( Arrays.binarySearch(str, "pen")+1) +"个");
2.用户输入型：
定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。
public class Test{
public static void main(String [] args){
String []str = {"apple", "banana","watermelon","peach","pear",
"lemon","mango","blueberry","longan","Durian"};
Scanner scanner = new Scanner(System.in);
System.out.print("请输入需要查找的水果名称:");
String inputStr = scanner.next();
boolean flag = false;
for (String string : str) {
if (string.equals(inputStr)) {
flag = true;
}
}
if (flag) {
System.out.println("YES");
} else {
System.out.println("NO");
}
scanner.close(); //关闭扫描
}
}
2. 获取数组最大值和最小值
利用Java的Math类的random()方法，编写函数得到0到n之间的随机数，n是参数（传入100）。并找出产生50个这样的随机数中最大的、最小的数，并统计其中>=60的有多少个。
提示：使用 int num=(int)(n*Math.random());获取随机数
public class Test{
public static void main(String [] args){
//调用创建数组函数
int [] arr = getArray(100);
//获取数组的最大值
int max = getMax(arr);
//获取数组的最小值
//int min = getMin(arr);
//输出数组
System.out.println(Arrays.toString(arr));
System.out.println("此数组的最大值为" + max + "\n此数组的最小值为" + getMin(arr));
//统计大于60的数的个数
int nums = greater60(arr);
System.out.println("数组中大于60的数的个数为"+ nums);
}
public static int greater60(int[] arr){
//定义数字个数
int nums = 0;
//遍历并统计
for(int i = 0; i < arr.length; i++){
if(arr[i] >= 60){
nums++;
}
}
return nums;
}
public static int[] getArray(int n){
//用传入的数值创建并初始化数组
int [] arr = new int [50];
//遍历赋值
for(int i = 0; i < arr.length; i++){
//创建随机数
int num = (int) (n*Math.random());
arr[i] = num;
}
return arr;
}
public static int getMax(int[] arr){
int max = arr[0];
//遍历比较，找到最大值
for(int i = 0; i < arr.length; i++){
if(arr[i] > max){ //比最大值还大=>更改最大值
max = arr[i];
}
}
return max;
}
public static int getMin(int[] arr){
int min = arr[0];
//遍历比较，找到最大值
for(int i = 0; i < arr.length; i++){
if(arr[i] < min){ //比最小值还小=>更改最小值
min = arr[i];
}
}
return min;
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
