java数组

#数组
所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际又会牵扯到内存分配，数组变量是引用（地址）型变量
数组相关概念：
数组名、元素、角标、下标、索引
数组的长度：元素的个数 length
数组的特点：
数组是有序排列的
数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
创建数组对象会在内存中开辟一整块连续的空间
数组的长度一旦确定，就不能更改。
数组的分类
按照维数：一维数组、二维数组、… …
按照数组元素的类型：基本数据类型元素的按钮、引用类型元素的数组
数组的定义
1、声明并开辟数组
2、静态初始化数组
数组先开辟内存空间，而后再使用索引进行内容的设置，实际上这种做法都叫做动态初始化，而如果希
望数组在定义的时候可以同时出现设置内容，那么就可以采用静态初始化完成。
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
数组的特点：数组长度是固定的。
注：使用new关键字分配内存时，简单类型的数组中的元素都有初始值
数组元素的默认初始化值
数组元素是整型：0
数组元素是浮点型：0.0
数组元素是char型：0或’\u0000’，而非’0’
数组元素是boolean类型：false，Oracle的JVM中采用byte[]方式进行存储
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];
初始化操作
arr[0]=10;
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
数组内存分配
数组是对象，也就是说可以以操作对象的方式来操作数组。并且数组在虚拟机中有它特别的类型。
既然是对象，遵循Java语言中的规则所有类的顶层父类都是Object。数组的顶层父类也必须是
Object，这就说明数组对象可以向上直接转型到Object，也可以向下强制类型转换，也可以使用
instanceof关键字做类型判定
String[]的直接父类就是Object而不是Object[]。可是Object[]的引用也可以指向String[]类型的对
象。数组类直接继承了Object，关于Object[]类型的引用能够指向String[]类型的对象，这种情况只
能是Java语法之中的一个特例，并不是严格意义上的继承。也就是说，String[]不继承自Object[]，
但是我可以允许你向上转型到Object[]，这种特性是赋予你的一项特权。
数组类直接继承了Object，关于Object[]类型的引用能够指向String[]类型的对象，这种情况
只能是Java语法之中的一个特例，并不是严格意义上的继承。也就是说，String[]不继承自
Object[]，但是我可以允许你向上转型到Object[]，这种特性是赋予你的一项特权。
如果有两个类A和B，如果B继承extends了A，那么A[]类型的引用就可以指向B[]类型的对
象。
数组操作方式
数组的访问通过索引完成，即：数组名称[索引]，但是需要注意的是，数组的索引从0开始，所以索
引的范围就是0 ~ 数组长度-1，例如开辟了3个空间的数组，所以可以使用的索引是0,1,2，如果此
时访问的时候超过了数组的索引范围，会产生ArrayIndexOutOfBoundsException 异常
当数组采用动态初始化开辟空间后，数组里面的每一个元素都是该数组对应数据类型的默认值
数组本身是一个有序的集合操作，所以对于数组的内容操作往往会采用循环的模式完成，数组是一
个有限的数据集合，所以应该使用 for 循环
在 Java 中提供有一种动态取得数组长度的方式：数组名称.length；
数组遍历通常使用for循环来实现。也可以用foreach实现
基础练习
1、创建一个长度为6的整数数组，数组中有六个整数(直接赋值或者键盘录入)。遍历数组中的每个元
素，元素之间用空格隔开
int a=100;
int[] arr1={a,2,6,7,9,4};
int[] arr2=new int[]{a,2,6,7,9,4};
int[] arr3=arr1;
System.out.println(arr);
//输出默认格式为：元素数据类型@数据的hash地址值。类似的还有md5、sha-1、sha-256等消息摘
要算法
for(int i=0;i<arr1.length;i++)
System.out.println(arr1[i]);
System.out.println(Arrays.toString(arr1));
public class Test4 {
public static void main(String[] args) {
int[] arr = new int[6];
//int[] arr=new int[]{0,0,0,0,0,0};
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
2、创建一个长度为6的整数数组。请编写代码，随机生成六个0-100之间的整数存放到数组中，然后再
计算出数组中元素的和并打印
3、定义一个数组来存储10个学生的成绩{72,89,65,87,91,82,71,93,76,68}，计算并输出学生的平均成绩
4、有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入
一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排
列的。
请输入一个整数数字： 50
生成的新数组是：12 14 23 45 50 66 68 70 77 90
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + “\t”);
}
sc.close();
}
}
public class Test5 {
public static void main(String[] args) {
int[] arr=new int[6];
for(int i=0;i<arr.length;i++) {
double d1 = Math.random() * 101;
arr[i]=(int)d1;
}
int sum=0;
for(int i=0;i<arr.length;i++)
sum+=arr[i];
String ss=“”;
for(int i=0;i<arr.length;i++) {
ss+=arr[i]+“+”;
}
ss=ss.substring(0,ss.length()-1)+“=”+sum;
System.out.println(ss);
}
}
public class Test6 {
public static void main(String[] args) {
int[] arr = { 72, 89, 65, 87, 91, 82, 71, 93, 76, 68 };
int sum=0;
for(int i=0;i<arr.length;i++) {
sum+=arr[i];
}
int avg=sum/arr.length;
System.out.println(“平均成绩”+avg);
}
}
public class Test7 {//操作成功的前提是数组中的数据有序
public static void main(String[] args) {
int[] old = { 12, 14, 23, 45, 66, 68, 70, 77, 90, 91 };
int kk = 10;
5、定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右
边。（可以创建其他数组，不必须在原数组中改变）
数组常见异常

1. NullPointerException 空指针异常
   原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。
   int[] newArray = new int[old.length + 1];
   boolean bb = true;
   for (int i = 0; i < old.length; i++) {
   if (old[i] < kk)
   newArray[i] = old[i];
   else {
   if (bb) {
   newArray[i] = kk;
   bb = false;
   }
   newArray[i + 1] = old[i];
   }
   }
   if(bb)
   newArray[old.length]=kk;
   for(int i=0;i<newArray.length;i++)
   System.out.print(newArray[i]+“\t”);
   }
   }
   public class Test8 {
   //定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右
   边。
   public static void main(String[] args) {
   int[] arr=new int[] {1,2,7,10,13};
   int[] brr=new int[arr.length];
   int k=0;
   int m=arr.length-1;
   for(int i=0;i<arr.length;i++) {
   if(arr[i]%2!=0) {
   brr[k]=arr[i];
   k++;
   }else {
   brr[m]=arr[i];
   m–;
   }
   }
   for(int i=0;i<brr.length;i++)
   System.out.print(brr[i]+“\t”);
   }
   }
2. ArrayIndexOutOfBoundsException 索引值越界
   原因：访问了不存在的索引值。数组角标越界异常:，注意：数组的角标从0开始。
   冒泡排序
   现有一个小数数组{12.9,53.54,75.0,99.1,3.14}。请编写代码，找出数组中的最小值并打印
   Java常见排序算法有冒泡、插入、选择、快速、希尔、归并和堆7种
   冒泡排序O(n**2) 稳定
   快速排序O(NlogN) 不稳定
   随机生成20个整数，使用冒泡排序，然后打印输出
   public static void main(String[] args) {
   int[] obj=null;
   System.out.println(obj.length);
   }
   int[] arr=new int[]{1,2,3,4,5};
   for(int i=0;i<=arr.length;i++)
   System.out.println(arr[i]);
   public class Test1 {
   public static void main(String[] args) {
   double[] arr = { 12.9, 53.54, 75.0, 99.1, 3.14 };
   for (int k = 1; k < arr.length; k++) {
   for (int i = 0; i < arr.length - k; i++) {
   if (arr[i] > arr[i + 1]) {
   double tmp = arr[i];
   arr[i] = arr[i + 1];
   arr[i + 1] = tmp;
   }
   }
   }
   for (double tmp : arr) {
   System.out.print(tmp + “\t”);
   }
   }
   }
   public class Test2 {
   public static void main(String[] args) {
   int[] arr = new int[20];
   for(int i=0;i<arr.length;i++) {
   int r=(int)(Math.random()*100); //生成0-100的随机整数，含0不含100
   arr[i]=r;
   }
   for(int temp:arr) //foreach结构，简化的方法遍历数组中的所有元素
   System.out.print(temp+" “);
   System.out.println();
   查找算法
   遍历查找
   时间复杂度为O(n)
   折半查找
   前提是数据必须有序
   //冒泡排序
   for(int i=1;i<arr.length;i++) { //控制循环次数
   for(int k=0;k<arr.length-i;k++) { //相邻比较
   if(arr[k]>arr[k+1]) {
   int tmp=arr[k]; //交换位置
   arr[k]=arr[k+1];
   arr[k+1]=tmp;
   }
   }
   }
   for(int temp:arr)
   System.out.print(temp+” ");
   }
   }

int[] arr = new int[21];
for(int i=1;i<arr.length;i++) {
int r=(int)(Math.random()*100);
arr[i]=r;
}
arr[0]=33;
for(int temp:arr)
System.out.print(temp+" “);
System.out.println();
int i=0;
for(;i<arr.length;i++){
if(arr[i]==target){
break;
}
}
System.out.println(i);
public class Test2 {
public static void main(String[] args) {
int[] arr = new int[21];
for (int i = 1; i < arr.length; i++) {
int r = (int) (Math.random() * 100);
arr[i] = r;
}
arr[0] = 33;
for (int i = 1; i < arr.length; i++) {
for (int k = 0; k < arr.length - i; k++) {
if (arr[k] > arr[k + 1]) {
时间复杂度为O(logN)
int tmp = arr[k];
arr[k] = arr[k + 1];
arr[k + 1] = tmp;
}
}
}
for(int tmp:arr) System.out.print(tmp+” “);
System.out.println();
int target = 33;
int pos=-1;
int m1 = 0;
int m2 = arr.length - 1;
boolean flag=false;
while (m1 <= m2) {
pos = (m1 + m2) / 2;
if (arr[pos] > target) {
m2 = pos - 1;
} else if (arr[pos] < target) {
m1 = pos + 1;
} else {
flag=true;
break;
}
}
if(flag)
System.out.println(pos+”::"+arr[pos]);
else
System.out.println(“找不到”);
}
}