数组
数组的定义：
数组是一组相同数据类型元素的集合。在Java中数组属于引用类型，即数组是一个对象。这里的数据类型不仅含八大基本数据类型，还包含引用数据类型，如数组里面可以存数组,数组里面可以存放字符串。
数组的作用：
在程序中常常需要使用数组，利用循环可以对数组中的数据进行批量操作，大大提高了效率，十分方便。
数组的特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型，不可以出现混合类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
- 数组本身就是对象，Java中对象是在堆中的，因此数据无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
数组的优缺点
优点：
- 按照索引查询元素速度快；
- 能存储大量数据；
- 按照索引遍历数组方便；
- 数组定义简单，而且访问很方便；
- 可以随机访问其中的元素。
缺点：
-
根据内容查找元素速度慢；
-
数组的大小一经确定不能改变，不适合动态存储；
-
数组智能存储一种类型的数据；
-
增加、删除元素效率慢；
-
未封装任何方法，所有操作都需要用户自己定义；
-
数组的空间必须是连续的，这就造成数组在内存中分配空间时必须找到一块连续的内存空间。所以数组不可能定义的太大，因为内存中不可能有那么多大的连续的内存空间，而解决这个问题的方法就是使用链表。
数组的定义
int [] 数组名;
int 数组名 [];
数组的初始化：
静态初始化：
定义数组时直接给定数组的值
数据类型 [] 变量名 = {val1，val2… }
数据类型 [] 变量名 = new []数据类型{val1,val2,val3…}
int[] arr = {3,4,5,6,100};
int[] arr2 = new int[] {3,4,5,6,100};
动态初始化：
定义数组时给定数组的长度
int [] 数组名= new int[数组长度]
动态赋值时，数组中的数据都是当前数据的默认值。
boolean [] arr1 = new boolean[3];
double [] arr2 = new double[2];
String [] arr3 = new String[2];
也可以通过先定义数组，再赋值的形式
int [] arr;
arr =new int[] {1,2,3,4,5};
int [] arr2 = new int[3];
System.out.println(arr2[1]);//>>>>0
arr2 = new int[]{1,2,3};
System.out.println(arr2[1]);//>>>>2
动态和静态的优缺点：
1.对于动态初始化，只需要给定数组的长度即可，适用于数据不确定的情况下
2.静态初始化，可以使用简化写法定义数组，适合数据一开始就存在的情况。
数组取值、赋值：
赋值：
静态赋值：
//数据类型[] 数组名 = {元素1,元素2,元素3,,.....};
//数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,.....};
int arr[index] = value; //向数组的 index 索引处 存放value 值
int arr[] = {value1,value2,...,value10} ;
动态赋值：
for(int i = 0;i<arr.length;i++){
arr[i] = i;
}
取值
打印数组名的时候，实际显示的是数组的地址值
double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2
(数组的遍历)
数组在内存中的表现
数组的使用
数组遍历：
fori形式：
//数组的遍历
int[] arr = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 88, 9, 0};
//获取数组的长度 数组名.length
System.out.println(arr.length);
//方法1：使用下标遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
增强for：
优点：不需要获取数组的长度，格式清晰
缺点：不够灵活，例如数组隔一个取值的情况，增强for就完成不了
for (int i : arr) {
System.out.println(i);
}
获取最值：
public static int[] getMaxMin(int[] arr) {
//定义一个变量接收最大值和最小值
int tempmax = arr[0];
int tempmin = arr[0];
for (int i : arr) {
if (i > tempmax) {
tempmax = i;
}
if (i<tempmin){
tempmin = i;
}
}
int [] maxmin = new int[]{tempmax,tempmin};
return maxmin;
}
数组的逆序
public static int[] reversearr(int [] arr){
for (int i = 0; i <arr.length/2 ; i++) {
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
return arr;
}
查找数组中是否有对应的值
/*
有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青仪斧王
猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称 【查找】
*/
//2.查找
class ArrayUtils1_2
{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//1.声明并初始化
String[] names = {"白眉鹰王","青翼蝠王","金毛狮王","紫衫龙王"};
//2.查找
System.out.println("请输入你要查找的名:");
String search = input.next();
boolean flag = false;
for(int i=0;i<names.length;i++){
if(names[i].equals(search)){//找到了
System.out.println("找到了，下标是："+i);
flag = true;
break;//跳出循环
}
}
if(!flag){
System.out.println("没找到");
}
}
冒泡排序
//冒泡排序
class ArrayUtils1_3
{
public static void main(String[] args)
{
int[] arr = {2,3,4,1,5};
//排序
/*
i j
0 0 arr[0] vs arr[1]
1 arr[1] vs arr[2]
2 arr[2] vs arr[3]
3 arr[3] vs arr[4]
*/
for(int i=0;i<arr.length-1;i++){//外层循环。 i:控制轮数
//循环操作：每一轮发生的事情
for(int j=0;j<arr.length-1-i;j++){//内层循环。j:控制比较的次数
//循环操作：每一次发生的事情（比较）
if(arr[j]<arr[j+1]){
//交换两个相邻元素
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//打印
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
}
}
去除数组中特定的值
int oldArr[] = {1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5};
//计算旧数组不为0时的长度
int count = 0;
for (int i : oldArr) {
if (i != 0) {
count++;
}
}
//创建一个新数组
int newArr[] = new int[count];
int index = 0;
//遍历旧数组，不为0的值放入新数组
for (int j : oldArr) {
if (j != 0) {
newArr[index++] = j;
}
}
for (int k : newArr) {
System.out.println(k);
}
//方法2：
int newArr2[] = new int[count];
int indexs = 0;
for (int m : oldArr) {
if (m!=0){
newArr2[indexs++] = m;
}else {
continue;
}
}
for (int n : newArr2) {
System.out.println(n);
}
合并数组，并排序
public class MergeArry {
/*
数组A：1，7，9，11，13，15，17，19；数组b：2，4，6，8，10 两个数组合并为数组c，按升序排列。
*/
public static void main(String[] args) {
int[] arr1 = new int[]{1,7,9,11,13,15,17,19};
int[] arr2 = new int[]{2,4,6,8,10};
int[] c = new int[arr1.length+arr2.length];
//设置两个数组的下标
int indexa = 0;
int indexb = 0;
int indexc = 0;
//若两个数组都是有序的，直接定义两个数组的下标，判断哪个下标的值大，值大的下标+1，接收的数组一直接收值较小的的数组的值，且下标++
//若两个数组是无序的，则需进行排序,Arrays.sort(arr1);
while (indexa<arr1.length && indexb<arr2.length) {
if (arr1[indexa] > arr2[indexb]) {
c[indexc]=arr2[indexb];
indexb++;
indexc++;
}else {
c[indexc]=arr1[indexa];
indexa++;
indexc++;
}
}
//若arr1有剩余
while (indexa<arr1.length){
c[indexc]=arr1[indexa];
indexa++;
indexc++;
}
//若arr2有剩余
while (indexb<arr2.length){
c[indexc]=arr1[indexb];
indexb++;
indexc++;
}
for (int i : c) {
System.out.println(i);
}
}
}
二分查找
/*
二分查找的前提：有序
1.取数组第一个元素为front，最后一个元素为end，所以mid=（front+end）/2
2.用mid下标所在位置的值和目标值比较，
若目标值大于mid下标所在的值，则说明目标值在数组的后半段，把mid的下标赋值给front，end不变，mid等于被赋值后的（front+end）/2
若目标值小于mid下标所在的值，则说明目标值在数组的前半段,，把mid的下标赋值给front，end不变，mid等于被赋值后的（front+end）/2
若目标值等于mid下标所在的值，则返回mid
3.递归上述方法，直到front>end
*/
public static void halfFindFunc(int[] arr, int target, int front, int end) {
//定义出mid，每次递归时mid都会发生变化。
int mid = (front + end) / 2;
//若mid下标所在的值小于目标值
if (arr[mid] < target) {
//当front下标小于end下标时
if (front < end) {
front = mid + 1;//防止出现下标相等时死循环
halfFindFunc(arr, target, front, end);
} else {
//当front下标大于end下标时，跳出递归
System.out.println("目标值不在数组中");
}
//若mid下标所在的值大于目标值
} else if (arr[mid] > target) {
//当front下标小于end下标时
if (front < end) {
end = mid - 1;//防止出现下标相等时死循环
halfFindFunc(arr, target, front, end);
}else {
//当front下标大于end下标时，跳出递归
System.out.println("目标值不在数组中");
}
//当mid下标所在的值与target相等时，返回其下标值
} else {
System.out.println("查询" + target + "到下标为" + mid);
}
二维数组：
动态初始化：
//格式1：
int [][] arr = new int[3][2]
二维数组中有三个一维数组
每个一维数组有两个元素
一维数组的名称分别为：arr[0],arr[1],arrp[2]
//格式2：
int [][] arr = new int[3][];
二维数组中有3个一维数组。
每个一维数组都是默认初始化值为null。
arr[0] = new int[3];arr[1] = new int [1];arr[2] = new int[2];
注意：
int [][] arr = new int [][2];非法
静态初始化
int [][] everynum = new int[][]{{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
String [][] arrayName={{值1,值2,值3},{值1,值2,值3}};
二维数组的遍历
for (int[] ints : everynum) {
for (int anInt : ints) {
System.out.println(anInt);
}
}
每个一维数组都是默认初始化值为null。
arr[0] = new int[3];arr[1] = new int [1];arr[2] = new int[2];
注意：
int [][] arr = new int [][2];非法
### 静态初始化
```java
int [][] everynum = new int[][]{{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
String [][] arrayName={{值1,值2,值3},{值1,值2,值3}};
二维数组的遍历
for (int[] ints : everynum) {
for (int anInt : ints) {
System.out.println(anInt);
}
}
扫一扫
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
