数组
数组：数组是存储同一种数据类型数据的集合容器。
数组的定义格式：
数据类型[] 变量名 = new 数据类型[长度];
数组的好处：对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标）,索引值的范围是从0开始，最大是：长度-1。
局部变量：如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。
成员变量：成员变量就是定义在方法之外，类之内的.
数组中最常见的问题：
1.NullPointerException 空指针异常原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。
2.ArrayIndexOutOfBoundsException索引值越界。原因：访问了不存在的索引值。
数组的初始化方式：
动态初始化:
数据类型[] 变量名 = new 数据类型[长度];
静态初始化：
数据类型[] 变量名 = {元素1，元素2.....};如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果数据一开始还不太明确，这时候就建议使用动态初始化。
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.print(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();
}
*/
}
}class Demo8 {
public static void main(String[] args)
{
int[] arr = {-12,-14,-5,-26,-4};
int max = getMax(arr);
System.out.println("最大值："+ max);
}
public static int getMax(int[] arr) {
int max = arr[0]; //用于记录最大值
for(int i = 1 ; i < arr.length ; i++){
if(arr[i]>max){ //如果发现有元素比max大，那么max变量就记录该元素。
max = arr[i];
}
}
return max;
}
}选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。
class Demo9 {
public static void main(String[] args) {
int[] arr = {12,5,17,8,9}; //对于5元素的数组，只需要找出4个最大值就可以排序了。
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;
}
}
}
//遍历数组，查看效果
System.out.print("目前的元素：");
for (int i = 0 ; i<arr.length ;i++){
System.out.print(arr[i]+",");
}
}
}冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。
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[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]+",");
}
}
}折半查找法(二分法): 使用前提必需是有序的数组。
class Demo12 {
public static void main(String[] args) {
int[] arr = {12,16,19,23,54};
//int index = searchEle(arr,23);
int index = halfSearch(arr,116);
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;
}
}二维数组： 二维数组就是数组中的数组。
二维数组的定义格式：
数据类型[][] 变量名 = new 数据类型[长度1][长度2];
二维数组 的初始化方式：
动态初始化:
数据类型[][] 变量名 = new 数据类型[长度1][长度2];
静态初始化：
数据类型[][] 变量名 = {{元素1,元素2...},{元素1,元素2...},{元素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.数组中的元素与元素之间的内存地址是连续的。
