编程基础 ( 4 )数组

数组的定义：

概念：同一种类型数据的集合，其实数组就是一个容器

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这引起元素

格式1：元素类型[]数组名 = new元素类型[元素个数或数组长度]

示例： int[] arr = new int[5]；

格式2：元素类型[]数组名 = new元素类型[] {元素，元素，……}；

示例： int[] arr = new int[] {3,5,1,7}； int[] arr = {3,5,1,7}；

Java内存结构

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

栈内存

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

堆内存

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

方法区，本地方法区，寄存器

实体在堆内存中都有默认初始化值：int为0，double为0.0，flaot为0.0f，boolean为false

只有引用型数据才能引用常量null

int[] arr = new int[]{3,1,6,5};//定义数组时，如果给定了初始值，[]里不要写元素个数，以免不对应。

//静态初始化-常见问题
class ArrayDemo2
{
public static void main(String[] args)
{
//int [] arr=new int[2];
//int arr[]=new int[2];这个数组名位子不一样没关系。

//int[] arr=new int[]{3,1,6,5,4};//定义了名称为arr的数组，是int类型的元素，通过大括号标出数组中元素内容。

//int[] arr={3,1,6,5,4};//上式的简化版，数据明确的时候用这种。

//int[] arr=new int [5];
//arr[0]=90;
//arr[1]=80;

//int[] arr=new int[3];
//System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3 操作数组时，访问到不存在的角标。

int[] arr=new int[3];
arr=null;
System.out.println(arr[1]);//NullPointerException 空指针异常。
//是指当引用没有任何指向值为null的情况，该引用还在用于操作实体。

}
}

//常见操作-遍历
class ArrayDemo3
{
public static void main(String[] args)
{
//数组的操作;
//获取数组中的元素。通常会用到遍历。

//int[] arr=new int[3];

int[] arr={3,6,5,1,8,9,67};
//数组中有一个属性可以直接获取到数组元素的个数。length.
//使用方法:数组名称.length=
System.out.println("length:"+arr.length);

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

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.print(arr[x]+"]");//意在去除最后一个元素后面的逗号。
}

}

}

//常见操作-获取最值
/*
给定一个数组｛5，1，6，4，2，8，9｝.
1，获取数组中的最大值以及最小值。
*/

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

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

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

public static int getMax(int[] arr)
{
int max=arr[0];
for (int x=1;x<arr.length ;x++ )
{
if (arr[x]>max)
{
max=arr[x];
}
}
return max;
}

/*
获取最大值的另一种方式。
可不可一将临时变量初始化为0呢？
可以。这种方式，其实在初始化为数组中任意一个角标。
*/
public static int getMax_2(int[] arr)
{
int max=0;
for (int x=1;x<arr.length ;x++ )
{
if (arr[x]>arr[max])
{
max=x;
}
}
return arr[max];
}

/*
获取最小值
*/

public static int getMin(int[] arr)
{
int min=0;
for (int x=1;x<arr.length ;x++ )
{
if (arr[x]<arr[min])
{
min=x;
}
}
return arr[min];
}
//获取double类型数组的最大值。因为功能一致，所以定义相同的函数名称，以重载的形式存在。
/*public static double getMax(double[] arr)
{
}
*/
public static void main(String[] args)
{
int[] arr= {5,1,6,4,2,8,9};
int max=getMax_2(arr);
System.out.println("Max="+max);
int min=getMin(arr);
System.out.println("Min="+min);
}

}

//排序-选择排序与冒泡排序
/*
对给定数组进行排序。
｛5，1，6，4，2，8，9｝
*/

class ArrayTest2
{
public static void main(String[] args)
{
int[] arr={5,1,6,4,2,8,9};
//在排序前打印；
printArray(arr);
selectSort(arr);
//排序后:
printArray(arr);
bubbleSort(arr);//另外 Java自带的排序  Arrays.sort(arr);在开发中，对数组排序使用该句代码。
printArray(arr);
}

/*
选择排序 最值出现在头角标位上。
*/

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 bubbleSort(int[] arr)
{
for (int x=0;x<arr.length-1 ;x++ )//冒泡排序还有一种方法for(int x=arr.length-1;x>0;x--)
// for(int y=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 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 swap(int []arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}

/*
数组的查找操作。
*/
class ArrayTest3
{
public static void main(String[] args)
{

int[] arr={3,2,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;
}
}

class ArrayTest4
{
public static void main(String[] args)
{
int[] arr={2,4,5,7,19,32,45};
int index=halfSearch_2(arr,50);          //运行后结果是index=5
System.out.println("index="+index);
}
/*
折半查找。提高效率，但是必须要保证该数组是有序的数组。
*/
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(min+max)/2;

while (arr[mid]!=key)
{
if (key>arr[mid])
{
min=mid+1;
}
else if (key<arr[mid])
{
max=mid-1;
}
if (min>max)
{
return -1;   //输入的不是数组中的元素 ，其结果会是-1
}
mid=(max+min)/2;
}

return mid;

}
/*
折半的第二种方式。
*/
public static int halfSearch_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while (min<=max)
{
mid=(max+min)>>1;
if (key>arr[mid])
{
min=mid+1;
}
else if (key<arr[mid])
{
max=mid-1;
}
else
return mid;
}
return -1;
}
}

/*
数组的查找
练习：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的。
如何获取该元素在数组中的位置。
*/

class ArrayTest5
{
public static void main(String[] args)
{
int[] arr={2,4,5,7,8,19,32,45};
int index=getIndex_2(arr,7);
System.out.println("index="+index);   //结果是index=3
}

public static int getIndex_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while (min<=max)
{
mid=(max+min)>>1;

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

return min;
}
}

//进制的转换。
class ArrayTest6
{
public static void main(String[] args)
{
toBin(6);
System.out.println(Integer.toBinaryString(60));
toHex(60);
}

/*
十进制-->二进制
*/
public static void toBin(int num)
{
StringBuffer sb=new StringBuffer();//存数据的容器。

while (num>0)
{
//System.out.println(num%2);
sb.append(num%2);//append 添加 算一个添加一个。
num=num/2;
}
System.out.println(sb.reverse());//reverse 算术反转。  输出是110

}

/*
十进制-->十六进制。
*/
public static void toHex(int num)
{
StringBuffer sb=new StringBuffer();//存数据的容器。
for (int x=0;x<8 ;x++ )
{
int temp=num&15;//十进制15就是十六进制的后四位1111的值，&于运算一假为假
//0为假，1为真%15即和0000-0000 0000-0000 0000-0000 0000-1111做与运算。
//也就是取二进制的最后四位出来。
if(temp>9)
//System.out.println((char)(temp-10+'A'));//这里char就是表示为字符型，16进制中0~9，第10位是A。
sb.append((char)(temp-10+'A'));
else
//System.out.println(temp);
sb.append(temp);
num=num>>>4;

}
System.out.println(sb.reverse());//reverse 算术反转
}

}

//查表法进制的转换。
class ArrayTest7
{
public static void main(String[] args)
{
toHex(60);
}
/*
0 1 2 3 4 5 6 7 8 9  A  B  C  D  E  F  ==十六进制中的元素
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

查表法：将所有的元素临时存储起来。建立对应关系、
每一次&15后的值作为索引去查建立好的表。就可以找对应的元素。
这样比-10+‘a’简单的多。
这个表怎么建立？
可以通过数据的形式来定义。
出结果后是反着的，可通过StringBuffer reverse功能来完成。不过还没学习过。
所以可以通过使用已经学习过的容器：数组开完成存储。
*/
public static void toHex(int num)
{
char[] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
//定义一个临时容器。
char[] arr=new char[8];

for (int x=0;x<8;x++)
{
int temp=num&15;

//System.out.println(chs[temp]);
arr[x]=chs[temp];

num=num>>>4;
}

//存储数据的arr数组遍历。
for (int x=arr.length-1;x>=0 ;x-- )  //从最大位元素倒着打印
{
System.out.print(arr[x]+",");  //输出结果是0，0，0，0，0，0，3，C
}
}
}

//查表法进制转换。
class ArrayTest8
{
public static void main(String[] args)
{
toHex(60);
}

public static void toHex(int num)
{
char[] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
//定义一个临时容器。
char[] arr=new char[8];
int pos=arr.length;

while (num!=0)
{
int temp=num&15;

arr[--pos]=chs[temp];

num=num>>>4;
}
System.out.println("pos="+pos);
//存储数据的arr数组遍历。
for (int x=pos;x<arr.length ;x++ )  //从最大位元素倒着打印
{
System.out.print(arr[x]+",");  //输出结果是 3，C，
}
}
}

class ArrayTest9
{
public static void main(String[] args)
{
toBin(6);
}

public static void toBin(int num)
{
//定义二进制的表。
char[] chs={'0','1'};
//定义一个临时存数容器。
char[] arr=new char[32];

//定义一个操作数组的指针
int pos=arr.length;

while (num!=0)
{
int temp=num&1;

arr[--pos]=chs[temp];

num=num>>>1;
}

for (int x=pos;x<arr.length ;x++ )
{
System.out.print(arr[x]);//toBin(6);输出结果是110
}
}

}

//进制转换的优化。
class ArrayTest10
{
public static void main(String[] args)
{
toBin(6);//6的二进制 输出结果是110
toHex(-6);//-6的十六进制 输出结果是FFFFFFFA
toOctal(-60);//-60的八进制 输出结果是37777777704
}
/*
十进制-->二进制
*/
public static void toBin(int num)
{
trans(num,1,1);
}
/*
十进制-->八进制
*/
public static void toOctal(int num)
{
trans(num,7,3);
}
/*
十进制-->十六进制
*/
public static void toHex(int num)
{
trans(num,15,4);
}

public static void trans(int num,int base,int offset)
{
if (num==0)
{
System.out.println(0);
return;
}
char[] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};

char[] arr=new char[32];

int pos=arr.length;

while (num!=0)
{
int temp=num&base;
arr[--pos]=chs[temp];
num=num>>>offset;
}

for (int x=pos;x<arr.length ;x++ )
{
System.out.print(arr[x]);
}
System.out.println();
}

}

//二维数组。
class Array2Demo
{
public static void main(String[] args)
{
//int[] arr=new int[3];//一维数组。

//int[][] arr=new int[3][4];//定义了名称为arr的二维数组。二维数组中有3个一维数组。
//每一个一维数组中有四个元素。
//System.out.println(arr[0][1]);

/*
int[][] arr=new int[3][];

arr[0]=new int[3];
arr[1]=new int[1];
arr[2]=new int[2];

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

*/
int[][] arr={{3,5,1,7},{2,3,5,8},{6,1,8,2}};

int sum=0;
for (int x=0;x<arr.length ;x++ )
{
for (int y=0;y<arr[x].length ;y++ )
{
sum=sum+arr[x][y];
}

}
System.out.println("sum="+sum);//结果是sum=51

}
}