目录
1:空指针异常, 当一个数组对象为null是,还进行调用方法和数字属性,
2:数组越界异常(ArrayOutIndexOfBoundException)
什么是数组?
数组占据一块连续的内存并按照顺序存储
一:创建数组(int a[]=new int[5];)
1:声明数组(定义数组有两种方式)
type [] arr_name;//推荐使用
type arr_name [];//c#中不支持
————注意:(1)声明数组不可指定长度,即int [5] a;这种做法是错的,仅仅是声明数组是不可指定长度。
2:创建数组(两种方法,通过new标识符创建数组对象)
(1) int arr_name;
arr_name=new int[10];//注:数组下标是从0到9。先声明在数组,在创建数组
(2) int [] args=new int[5];//声明的同时创建数组,两种效果一样的。
3:初始化数组(初始化数组有两种方式)
静态初始化:在定义数组的同时就为数组元素分配空间并赋值。
程序员无需指定数组长度,指定该数组的元素即可,由系统自动复制
int [] arr; //只是在main方法中定义了一个arr数组变量,并未指向任何有效内存,只用一个栈 内存没有堆内存,所以声明的时候只声明了栈。
arr=new int[]{1,3,2,4,5};//分配了堆内存,即有了有效内存,数组所占的空间也被定了下来,堆内存中的对象 不 可以被直接访问,只能通过引用变量访问堆内存中的对象。
动态初始化:数组定义与为数组元素分配空间和赋值操作分开进行。
int [] a;
a=new int [3];
a[0]=1;a[1]=2;a[2]=3;//若不赋值,默认为0;
程序员只需指定数组的长度,即为每个数组元素指定所需的内存空间,系统将
为这些数组元素赋值。
//系统赋值的规则
byte, short, int, long类型的系统赋初值为0
float, double 类型的系统赋初值为0.0
char类型的系统赋初值为'\u0000'
引用类型(类,接口,数组)系统赋初值null
注意:Java数组是静态的,一旦为数组初始化完成,数组元素的内存分配空间即结束,
程序只能改变数组元素的值无法改变数组的长度。
4:访问数组
通过数组下标访问数组,a[0]访问的是数组中的第一个元素;
5:数组长度( 如何得到数组的长度)
length属性(全局变量),a.length的值为数组的长度,System.out.println(a.length);直接输出数组的长度
a.length不是length()方法;
如果要得到String类型的长度,需要用到其他的length()方法
二:数组排序
1:选择排序
public class SelectSort
{
private int [] a={12,3,23,34,16,11};
public void selectSort()
{
System.out.println("开始排序");
int arrayLength = a.length;
for (int i = 0; i < arrayLength - 1 ; i++ )
{
int minIndex = i ;
for (int j = i + 1 ; j < arrayLength ; j++ )
{
if (a[i]-(a[j]) > 0)
{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
System.out.println(java.util.Arrays.toString(a));
}
}
public static void main(String[] args)
{
SelectSort s=new SelectSort();
System.out.println("排序之前:\n"
+ java.util.Arrays.toString(s.a));
s.selectSort();
System.out.println("排序之后:\n"
+ java.util.Arrays.toString(s.a));
}
}
2:冒泡排序
public static void bubbleSort(int [] a){
for(int i=0;i<a.length-1;i++){
for(int j=0;j<a.length-1-i;j++){
int tmp=0;
if(a[j]-a[j+1]>0){
tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
}
}
3:快速排序
public class A {
public static void main(String[] args){
int [] a={8,7,5,2,3,6};
quickSort(a,0,a.length-1);
for(int k:a){
System.out.println(k);
}
}
public static void quickSort(int [] a,int start,int end){
int i=start;
int j=end;
boolean flag=true;
if(i>=j){
return;
}
while(i!=j){
if(a[i]>a[j]){
int t=0;
t=a[i];
a[i]=a[j];
a[j]=t;
flag=!flag;
}
if(flag){
j--;
}else{
i++;
}
}
i--;
j++;
quickSort(a,start,i);
quickSort(a,j,end);
}
}
三:遍历数组
1:for循环遍历数组
int[] a=new int[100];
for(int i=0;i<100;i++){
a[i]=i;
System.out.println(a[i]);
}
2:for each 遍历数组
int[] a=new int[]{1,2,3,4,5,6,7};
for (int i : a) {
System.out.println(i);
}
四:典型的数组处理
1:复制数组
把一个数组的值,复制到另一个数组中
private static void copyArray(){
int a[]={2,3,4,5,1,90,12};
int n=a.length;
double[] b=new double[n];
for(int i=0;i<n;i++){
b[i]=a[i];
}
for(double i :b){
System.out.println(i);
}
}
2:找出数组中最大的元素
public class Max {
public static void main(String[] args){
int [] a={1,3,56,23,2,5};
int tem=a[0];
for(int i=0;i<a.length;i++){
if(a[i]>tem)
tem=a[i];
}
System.out.println(tem);
}
}
3:计算数组元素的平均值
public class Average {
public static void main(String[] args){
int [] a={1,2,3,4};
double sum=0.0;
for(int i=0;i<a.length;i++){
sum=sum+a[i];
}
System.out.println(sum/a.length);
}
}
4:颠倒数组元素的顺序
private static void reversalArray(){
double a[]={2,3,4,5,1,90};
int n=a.length;
for(int i=0;i<n/2;i++ ){
double temp=a[i];
a[i]=a[n-1-i];
a[n-1-i]=temp;
}
for(double i :a){
System.out.println(i);
}
}
5:二分查找法//折半查找
(1)优缺点:①优点:比较次数少,查找速度快,平均性能好。
②缺点:要求待查表为有序表,且插入删除困难
(2)适用于:适用于不经常变动而查找频繁的有序列表。//!!!所以二分查找之前一定要排序。
(3)时间复杂度:O(log2 n)
(4)算法原理:当有一连串数字(1,2,3,4,7,8,9,6,5)时,//先将无序数组进行排序,在二分(1,2,3,4,5,,6,7,8,9)
确立关键字key(你要查找的值,比如你要找到数字6,那么6就是你的关键字),
算法中使用了lo和hi两个变量,将0设置为lo,arr.length-1设置为hi,
索引叫mid,即mid=(lo+hi)/2,将key与arr[mid]进行比较
当key小于中间值arr[mid],说明key在lo和arr[mid]中间,这时将hi向中间值的左端移动,即hi=mid-1。
当key大于中间值arr[mid],说明key在hi和arr[mid]中间,这时将lo向中间值的右端移动,即lo=mid+1。
否则返回mid。
重复比较arr[mid]的值与key的值,直到找到key为止
(5)实现:①JDK方法实现:
②手动二分查找://查找之前一定要排序!!!(多提了几次)
public class Abinary {
public static void main(String args[]){
//erfen
int []a={2,1,3,4,5};
Arrays.sort(a);
System.out.println(Arrays.binarySearch(a,1));
System.out.println(binarySearch(1,a));
}
public static int binarySearch(int key,int a[]){
int low = 0;
int high = a.length-1;
while(low<=high){
int mid=(low+high)/2;
if(key<a[mid]){
high=mid-1;
}else if(key>a[mid]){
low=mid+1;
}else{
return mid;
}
}
return -1;
}
}
五:二维及多维数组
1:初始化二维数组(数组的数组,Java中没有真正的数组)
格式:数组类型[][] 数组名称=new 数组类型[第一维长度 行][第二维长度 列];
(1)int [] [] a=new int [2][3];
(2)int [] [] b=new int [2][];
b[0]=new int [5];
b[1]=new int [3];
七:使用数组需要注意的问题
1:空指针异常, 当一个数组对象为null是,还进行调用方法和数字属性,
2:数组越界异常(ArrayOutIndexOfBoundException)