黑马程序员——数组

数组


概念：同一种类型数据的集合，其实数组就是一个容器。
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名=new 元素类型[元素个数或数组长度]；


示例： int[] arr = new int[5];
格式2:
元素类型[] 数组名 = new 元素类型[]{元素，元素，。。。};
int[] arr = new int []{1,3,5,7};
int[] arr = {1,3,5,7};


//需求：想定义一个可以存储3个整数的容器。


int[] x = new int [3]; 


//打印数组中角标为0的元素的值。


System.out.println(x[0]);


//给角标为0赋值


x[0] = 50;


//x = null；（x指向为空，跟堆内存无关，不再引用。）


内存结构


java程序在运行时，需要在内存中的分配空间。为了提高运算效率，
又对空间进行了不同区域的划分，因为每一片区域都有特定的处理
数据方式和内存管理方式。


栈内存
用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存
数组和对象，通过new简历的实例都存放在堆内存中。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值。
实体不在被使用，会在不确定的时间内被垃圾回收期回收。


方法区。本地方法区。寄存器。（以后再说）。




//遍历数组中的元素


int[] arr = new int[3];
for(int x=0; x<3; x++){

System.out.println("arr["+x+"]="+arr[x]+";");
}
     --------------------------------------------------------------
int[] arr = {3,6,5,1,8,9};
for(int x=0; x<6; x++){

System.out.println("arr["+x+"]="+arr[x]+";");
}
//如果数组中的元素太多，不可能一个一个的去数。
//数组中有一个属性可以直接获取到数组元素个数。length。
//使用方式：数组名称.length = 


System.out.println("length:"+arr.length);
-----------------------------------------------------
int[] arr = {1,2,3,4,5,6,7,8,9};
for(int x=0; x<arr.length; x++){

System.out.println("arr["+x+"]="+arr[x]+";");
}


但凡有数组的地方，通常会用到for循环，因为大多会用到遍历。


若求和。变量加循环。
int sum = 0;
for(int x=0; x<arr.length; x++){


sum += arr[x];
System.out.println("arr["+x+"]="+arr[x]+";");
}
System.out.println(sum);
--------------------------------------------------
//定义函数功能，用于打印数组中的元素。元素间用逗号隔开。


public.static void printArray(int[] arr){

for(int x=0; x<arr.length; x++){

System.out.print(arr[x]+",");
}
}//这样打印的结果在最后的一个数的后面会出现一个，怎样去掉呢？

public.static void printArray(int[] arr){


System.out.print("[")
for(int x=0; x<arr.length; x++){


if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");


}
}
----------------------------------------------------


System.out.println(arr);//打印出的结果没意义，打印的是arr
//这个数组的内存地址。16进制的哈希值。



//给定一个数组{1，2，3，4，5，6，7，8，9}。

获取数组中的最大值以及最小值。


/*
获取数组中的最大值。
思路：
1、获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定，
所以可以通过一个变量进行临时存储。
2、让数组中的每一个元素都和这个变量中的值进行比较。
如果大于了变量中的值，就用该变量记录较大值。
3、当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。


步骤：
1、定义变量。初始化为数组中任意一个元素即可。
2、通过循环语句对数组进行遍历。
3、在变量过程中定义判断条件，如果便利到的元素比变量中的元素打，就赋值给该变量


需要定义一个功能来完成，以便提高复用性。
1、明确结果，数组中的最大元素   int型。
2、有未知内容   一个数组。  int[]
*/


class N 
{
public static int getMax(int[] arr){


int max = arr[0];//int max=0;

for(int x=1; x<arr.length;x++){

if(arr[x]>max)//if(arr[x]>arr[max])
max = arr[x];//max = x;

}
return max;  //return arr[max]
}
public static void main(String[] args) 
{
int[] arr={1,2,3,4,5,6,7,8,9};


int max = getMax(arr);


System.out.println(max);
}
}
/*
获取最大值的另一种方式。
可不可以将临时变量初始化为0呢？
可以，这种方式，其实是在初始化为数组中任意一个角标。
0不作为元素存在，作为角标存在。
往上看注释的内容。
*/



//获取最小值。


class N 
{
public static int getMin(int[] arr){


int min = 0;//int min = arr[0]

for(int x=1; x<arr.length;x++){

if(arr[x]<arr[Min])//if(arr[x]<min)
min = x;   //min = arr[x];

}
return arr[min];  //return min;
}
public static void main(String[] args) 
{
int[] arr={1,2,3,4,5,6,7,8,9};


int min = getMin(arr);


System.out.println(min);
}
}


//这种方式是用角标的方式获取。用元素获取的方式。(上面//)


---------------------------------------------------------------------
//对给定数组进行排序。
选择排序
{5,1,6,4,2,8,9}


class ArrayTest2
{
public static void selectSort(int[] arr){

for (int x=0; x<arr.length-1; x++){

for(int y=x+1; y<arr.length; y++){

if(arr[x]>arr[y]){
/*
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
*/根据最下面的函数功能，可以直接写  swap(arr,x,y);
}
}
}
}//选择排序。内循环结束一次，最值出线在头角标位置上。


public static void main(String[] args){

int[] arr = {5,1,6,4,2,8,9};
//排序前；
printArray(arr);
//排序
selectSort(arr);
//排序后；
printArray(arr)；
}
public static void printArray(int[] arr){

System.out.print("[");
for(int x=0; x<arr.length; x++){

if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}

}
--------------------------------------------------------------


冒泡排序


public static void bubbleSort(int[] arr){

for(int x=0; x<arr.length-1; x++){//for (intx=arr.length-1;x>0;x--)
    //for(inty-0;y<x;y++)

for(int y=0; y<arr.length-x-1; y++){//-x：让每一次比较的元素减少，-1：避免角标越界

if(arr[y]<arr[y+1]){
/*
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
*/  根据下面的函数  可以直接写成swap(arr,y,y+1)
}
}
}
}



/*
发现无论什么排序，都需要对满足条件的元素进行位置置换。
所以可以吧这部分相同的代码提取出来，单独封装成一个函数。
*/
public static void swap(int[] arr,int a,int b){

int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}


-----------------------------------------------------------------------------------------


数组的查找操作。
class  ArrayTest
{
public static void main(String[] args) 
{
int[] arr = {3,1,5,4,2,9};
int index = getIndex(arr,2);
System.out.println("index="+index);
}
//定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。
public static int getIndex(int[] arr,int key){

for(int x=0;x<arr.length; x++){


if(arr[x]==key)
return x;
}
return -1;
}


/*
折半查找。提高效率，但是必须保证数组是有序的。
*/
public static int halfSearch(int[] arr;int key){

int min,mid,max;
min = 0;
max = length-1;
mid = (max+min)/2;

while(arr [mid]!=key){

if(arr [mid]>key)
max = mid - 1;
else(arr [mid]<key)
min = mid + 1;


if(min>max)
return -1;
mid = (max+min)/2;

}
return mid;
}
/*
折半的第二种方式  //练习：有一个有序的数组，想要将一个元素插入到该数组中，
还要保证该数组是有序的。如何获取该元素在数组中的位置。
其实就是下面这个程序改一下。
把最后的一个return -1；改成return min；
*/
public static int halfSearch_2(int arr[];int key){

int min = 0,max = arr.length-1,mid;


while(min<=max){

mid = (max+min)/2;


if(key>arr [mid])
min = mid +1;
else if(key<arr [mid])
max = mid -1;
else
return mid;
}
return -1; //return min;
}
}




数组中的数组
二维数组[][]
格式1： int[][] arr = new int[3][2];

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0],arr[1],arr[2]
给第一个一维数组1角标位赋值为78的写法是：arr[0][1] = 78;


格式2： int[][] arr = new int[3][];

二维数组汇总有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = ner int[1];
arr[2] = new int[2];


System.out.println(arr.length);//打印的是二维数组的长度
System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度。