Java基础-----数组

/*
数组：数组是同一种数据类型数据的集合容器。
数组的定义格式：
    数据类型[]  变量名 = new 数据类型[长度];


分析数组：
    左边： int[] arr 声明了一个int类型的数组变量，变量名为arr.


int:表示该数组容器只能存储int类型的数据。
[]:这是一个数组类型。
arr：变量名


右边：new int[50]:创建一个长度为50的int类型数组对象。
new：创建数组对象关键字。
int：表示该数组对象只能存储int类型数据。
[]：表示是数组类型
50：该数组最多能存储50个数据。数组的容量


数组的好处：被分配到数组对象中每一个数据都分配一个编号（索引值，角标，下标）




局部变量：如果声明一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。


成员变量：成员变量就是定义在方法之外，类之内的。




内存图：比较重要
int[] arr=new int[4];


=赋值运算符：
这时候=号是把数组对象内存地址赋予给arr变量。
jvm(虚拟机的其中两个内存：栈和堆)


栈内存的特点：栈内存存储的都是局部变量，变量一旦出了自己的作用域，那么马上会从内存中消失，释放内存空间
堆内存的特点：堆内存存储的都是对象数据，对象一旦被使用完，并不会马上从内存中消失，二十等待垃圾回收器不定时把垃圾对象回收，这时候该对象才会消失，释放内存


凡是new关键字创建的对象，jvm都会在堆内存中开辟一个新的空间，创建一个新的对象
对象如果没有变量引用了，那么该对象就是一个垃圾对象


需求：计算我们班第一次考试的平均成绩。
*/


class Demo4 
{
//int a = 4;//成员变量
public static void main(String[] args) 
{
//int a =4//局部变量


//定义一个数组
int[] arr=new int[4];
arr[0] = 10;
arr[1] = 30;
arr[2] = 50;
arr[3] = 90;


//System.out.println("数组的容量："+arr.length);//数组的有一个length的属性，可以查看数组的容量
//System.out.println("arr[2] = "+ arr[2]);
//查看数组中的所有数据
for (int index = 0;index<arr.length ;index++ )
{
System.out.println(arr[index]);
}
}

}

/*


int[] arr1 = new int[2];
int[] arr2 = new int[2];
arr1[1] =10;
arr2[1] =20;
凡是以new关键字创建的对象，jvm都会在堆内存中开辟新的空间用于创建新的对象
数组的内存分析：
*/


class Demo5 
{
public static void main(String[] args) 
{
/*
int[] arr1 = new int[2];
int[] arr2 = new int[2];
arr1[1] =10;
arr2[1] =20;
System.out.println(arr1[1]);//10



int[] arr1 = new int[2];
arr1[1] = 100;
int[] arr2 = arr1;
arr1[1] = 10;
arr2[1] = 20;
System.out.println(arr1[1]);//20


*/


int[] arr = new int[2];
arr = null;//null 让该变量不要引用任何的对象。不要记录任何的内存地址
        arr[1] = 10;
System.out.println(arr[1]);
}
}

/*
数组中最常见的问题：
   1. NullPointerException 空指针异常
原因：引用类型变量没有指向任何对象，而访问了对象的属性或者调用了对象的方法。
   2. ArrayIndexOutOfBoundsException 索引值越界。
   原因：访问了不存在的索引值




对象被使用完毕，并不会马上释放内存空间


垃圾对象：没有引用类型变量所指向的对象就是垃圾对象
*/


class Demo6 
{
public static void main(String[] args) 
{
/*
int[] arr = new int[2];
arr = null;//null 让该变量不要引用任何的对象。不要记录任何的内存地址
        arr[1] = 10;
System.out.println(arr[1]);
*/


int[] arr = new int[4];
arr[0] = 10;
arr[1] = 30;
arr[2] = 40;
arr[3] = 50;
for (int index=0;index<=arr.length;index++ )//.ArrayIndexOutOfBoundsException
{
System.out.println(arr[index]);
}

}
}

/*
数组的初始化方式：
    动态初始化：
   数据类型[] 变量名= new 数据类型[长度];
静态初始化：
 数据类型[] 变量名 = {元素1，元素2，元素3.....};


 如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化.
 如果数据一开始还不太明确，这时候建议使用动态初始化。


 静态和动态初始化内存都是一致的。




 需求：定义一个函数接收一个int类型的数组对象，找出数组对象中的最大元素返回给调用者


*/


class Demo7 
{
public static void main(String[] args) 
{
/*
//动态初始化
//int[] arr=new int[10];


//静态初始化
int[] arr={10,20,30,40,50};
for (int index=0;index<arr.length ;index++ )
{
System.out.println(arr[index]+",");
}
*/
int arr = new int[50];
Scanner scanner = new Scanner(System.in);
for (int i=0;i<arr.length ;i++ )
{
arr[i] = scanner.nextInt();
}

}
}

/*
需求：定义一个函数接收一个int类型的数组对象，找出数组对象中的最大元素返回给调用者
思路：
    定义一个变量用于记录最大值，然后使用该变量与数组中的每个元素进行比较，如果发现有元素比目前该变量所记录的值要大的，那么该变量记录目前记录比较的值




*/


class Demo8 
{
public static void main(String[] args) 
{
int[] arr = {12,14,5,26,5};
int max = getMax(arr);
System.out.println("最大值："+max);
}
public static int getMax(int[] arr){
int max=arr[0];//用于记录最大值
for (int i=0;i<arr.length ;i++ )
{
if (arr[i]>max){//如果发现有元素比max大，那么max变量就记录该元素


max = arr[i];
}
}
return max;

}
}

/*
思路：
    使用索引值为0的元素与其他位置的元素挨个比较一次，
如果有发现比0号索引值的元素大的，那么交换位置


需求：定义一个函数接收一个int类型的数组对象，把数组中的最大值放在数组中的第一轮




选择排序（直接排序）：使用一个元素与其他元素挨个比较一次，符合条件交换位置。
*/


class Demo9 
{
public static void main(String[] args) 
{
int[] arr = {12,5,17,8,9};//对于5个元素的数组，只需要找出四个个最大值就可以排序了
selectSort(arr);
}
public static void selectSort(int[] arr){
for (int j=0;j<arr.length-1 ;j++ ){//控制的轮数
for (int i = j+1;i<arr.length ;i++ ){//找出最大值


   if (arr[i]>arr[j]){
//交换位置
   int temp = arr[i];
   arr[i] = arr[j];
   arr[j] = temp;
      }
     }
}





    


/*
//把最大值放在首位置
for (int i = 1;i<arr.length ;i++ )
{
if (arr[i]>arr[0])
{//交换位置
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
}
}
//把老二放在第二个位置
for (int i=2;i<arr.length ;i++ )
{
if (arr[i]>arr[1])
{
int temp = arr[i];
arr[i]=arr[1];
arr[1]=temp;


}
}


//把老三放在第三个位置
for (int i=3;i<arr.length ;i++ )
{
if (arr[i]>arr[2])
{
int temp = arr[i];
arr[i]=arr[2];
arr[2]=temp;


}
}


//把老四放在第四个位置
for (int i=4;i<arr.length ;i++ )
{
if (arr[i]>arr[3])
{
int temp = arr[i];
arr[i]=arr[3];
arr[3]=temp;


}
}
*/


//遍历数组，查看效果
System.out.print("目前的元素:");
for (int i=0;i<arr.length ;i++ )
{
System.out.print(arr[i]+",");
}


}
}

/*
需求：定义一个函数接收一个int类型的数组对象，把数组中的最大值放在数组中的最后一位




思路：相邻的两个元素挨个比较，大的挡在右边，小的放在左边


冒泡排序：冒泡排序的思想就是使用相邻的两个元素挨个比较一次，符合条件交换位置


*/


class Demo10 
{
public static void main(String[] args) 
{
int[] arr={12,8,17,5,9};//最大的索引值：4 容量：5
bubbleSort(arr);
}
public static void bubbleSort(int[] arr){
for (int j=0; j<arr.length-1;j++ )//控制轮数
{
for (int i=0;i<arr.length-1-j ;i++ ){//找出最大值
//相邻的两个元素比较
      if (arr[i]>arr[j]){
     int temp = arr[i];
     arr[i] = arr[j];
     arr[j] = temp;
    }
   }


}




   /*
//把最大值放在最后一个位置
   for (int i=0;i<arr.length-1 ;i++ ){//3
//相邻的两个元素比较
   if (arr[i]>arr[i+1]){
  int temp = arr[i];
  arr[i] = arr[i+1];
  arr[i+1] = temp;
    }
   }


//把老二放在倒数第二个位置


for (int i=0;i<arr.length-2 ;i++ ){//3
//相邻的两个元素比较
   if (arr[i]>arr[i+1]){
  int temp = arr[i];
  arr[i] = arr[i+1];
  arr[i+1] = temp;
    }
   }


//把老三放在倒数第三个位置


for (int i=0;i<arr.length-3 ;i++ ){//3
//相邻的两个元素比较
   if (arr[i]>arr[i+1]){
  int temp = arr[i];
  arr[i] = arr[i+1];
  arr[i+1] = temp;
    }
   }
*/




//遍历数组，查看效果
System.out.print("目前的元素:");
for (int i=0; i<arr.length;i++ )
{
System.out.print(arr[i]+",");
}
}
}

/*
需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素zai8数组中的索引值，
如果目标元素不存在数组中，那么返回-1表示。


思路：
   定义三个变量分别记录要查找元素的范围最大索引值，最小索引值，中间的索引值，每次都是使用中间索引值的元素与目标
   元素比较一次，如果不是我们所需要的元素，那么缩小查找范围。


   不存在的情况：max<min
*/


class Demo12 
{
public static void main(String[] args) 
{
/*
int[] arr={12,16,19,23,54};
int index = searchEle(arr,23);
System.out.println("元素所在的索引值:"+index);
*/
int[] arr={12,16,19,23,54};
int index = halfSearch(arr,100);
System.out.println("元素所在的索引值:"+index);


}
public static int halfSearch(int[] arr,int target){
//定义三个变量分别记录最大，最小，中间的查找范围
int max= arr.length-1;
int min = 0;
int mid = (max+min)/2;
while (true)
{
if (target>arr[mid]){
       min=mid+1;
       }else if (target<arr[mid]){
max = mid -1 ;
       }else{
//找到了元素
return mid;

}
//没有找到的情况
if (max<min)
{
return -1;
}
//重新计算中间索引值
mid = (min + max)/2;


}


}
/*
public static int searchEle(int[] arr,int target){
for (int i= 0;i<arr.length ;i++ )
{
if (arr[i]==target)
{
return i;
}
}
return -1;

}
*/
}

/*
需求：定义一个函数接收一个char数组对象,然后翻转数组中的元素。


char[] arr={'a','b','c','d','e'}
*/


class Demo13 
{
public static void main(String[] args) 
{
char[] arr={'a','b','c','d','e'};
reverseSort(arr);



}
public static void reverseSort(char[] arr){
for (int startIndex=0,endIndex=arr.length-1;startIndex<endIndex ; startIndex++,endIndex--)
{
char temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
}
//遍历数组查看效果
System.out.print("目前的元素:");
for (int i=0;i<arr.length ; i++)
{
System.out.print(arr[i]+"");
}

}

}

/*
toString();输出数组（代替数组遍历）
排序（sort）
找出最大值
排序
找元素在数组中的位置（二分法必须用在有序的数组）


数组的工具类(Arrays)：


作业：自定实现一个Arrays的toString方法




*/
import java.util.*;
class Demo14 
{
public static void main(String[] args) 
{
int[] arr = {12,3,1,10,8};
//排序的方法
Arrays.sort(arr);
       //1,3,8,10,12
String info = Arrays.toString(arr);
System.out.println("数组的元素:"+info);
int index = Arrays.binarySearch(arr,5);//二分法查找:如果在数组中能找到对应的元素，那么就返回该数据的索引值；如果没有找到，那么就返回一个负数（不确定）表示
System.out.println("找到索引值:"+index);





}
}

/*
二维数组：二维数组就是数组中的数组。


一根    变量、
一盒  20根    一维数组


一条  10包 20根   200根  二维数组




二维数组的定义格式：


  数据类型[][] 变量名= new 数据类型[长度1][长度2]；
  长度1：一条烟有多少盒。
  长度2：一盒烟有多少根。




  二维数组的初始化方式：
  动态初始化：


      数据类型[][] 变量名 = new 数据类型[长度1][长度2]；


  静态初始化：
      数据类型[][] 变量名 = {(元素1，元素2.....),(元素1，元素2，元素3...),(元素1，元素2.....)....}




*/


class Demo15 
{
public static void main(String[] args) 
{
//定义一个二维数组
int[] [] arr = new int[3][4];
/*
System.out.println("二维数组的长度:"+arr.length);//3
System.out.println("二维数组的长度:"+arr[1].length);//4
*/


System.out.println("数组的元素:"+arr[1][1]);
}
}

/*
静态初始化：
      数据类型[][] 变量名 = {{元素1，元素2.....},{元素1，元素2，元素3...},{元素1，元素2.....}....}






    
*/


class Demo16 
{
public static void main(String[] args) 
{
int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};
//遍历二维数组
for (int i=0;i<arr.length ;i++ )
{
for (int j=0; j<arr[i].length; j++)
{
System.out.print(arr[i][j]+" ");
}

//换行
System.out.println();
}

}


//定义一个二维数组，然后计算二维数组中偶数的总和
}

/*
数组的特点：


    1.数组只能存储同一种数据类型的数据
2.数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始。最大索引值length-1
3.数组一旦初始化，长度固定。
4.数组中的元素与元素之间的内存地址是连续的。
*/


class Demo17 
{
public static void main(String[] args) 
{
int[] arr = new int[3];
arr = new int[4];
System.out.println(arr.length);//4
}
}