一、数组
同一种类型数据的集合,也就是一个容器。
声明：
1.元素类型[]数组名 = new元素类型[元素个数]
例：int[] arr = new int[5];
2.元素类型数组名[] = new元素类型[元素个数]
例：int arr[] = new int[5];
3.元素类型[]数组名 = new元素类型[]{元素1，元素2，元素3，......}；
例：int[] arr =new int[]{1,2,3,4};
int[] arr={1,2,3,4}
注：
JAVA中推荐用：类型[]数组名;
一个数组是一个对象
声明一个数组没有创建一个对象
声明时不用指定长度
创建基本数据类型数组：int[] i = new int[2];
创建引用数据类型数组：Student[] s = new Student[100];
数组创建后其中的元素有初始值
类型 黙认值
byte 0
short 0
int 0
long 0l
float 0.0f
double 0.0d
char \u0000
boolean false
reference types null
注：
创建时一定要指定长度
int[] i2=new int[]; //error
Java程序在运行时，需要在内存中分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存：
1. 数组和对象，通过new建立的实例都是存放在堆内存中。
2. 每一个实体都有默认初始化值。
3. 实体中的变量都有默认初始化值。
4. 实体不在被使用，会在不确定的时间内被垃圾回收器回收。
栈内存：自动释放。堆内存：垃圾回收机制。
Java的垃圾回收：
由一个后台线程gc进行垃圾回收
虚拟机判定内存不够的时候会中断代码的运行，这时候gc才进行垃圾回收
缺点：不能够精确的去回收内存
java.lang.System.gc(); 建议回收内存，但系统不一定回应，他会先去看内存是否够用，够用则不予理睬，不够用才会去进行垃圾回收
内存中什么算是垃圾：不在被引用的对象(局部变量，没有指针指向的)
二、数组的遍历
示例：
遍历数组
/*
遍历数组
*/
class Test
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5,6,7};
printArray(arr);//调用自定义函数
}
public static void printArray(int[] arr)//自定义遍历一维数组函数
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}
}
三、获取数组中最大值和最小值
/*
获取一维数组中的最大值和最小值
*/
class ArrayTest
{
public static int getMax(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];
}
public static void main(String[] args)
{
int[] arr={1,3,2,5,5};
System.out.println("max="+getMax(arr)+"\n"+"min="+getMin(arr));
}
}
四、数组元素排序（选择排序）
/*
需求：选择排序
思路：
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的
数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
*/
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;
}
}
}
}
public static void printArray(int[] arr)//自定义遍历一维数组函数
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}
public static void main(String[] args)
{
int[] arr={1,3,4,6,2,7,5};
System.out.print("排序前：");//排序前
printArray(arr);//调用打印函数
System.out.print("\n排序后：");//排序后
selectSort(arr);//调用排序函数
printArray(arr);//排序后
}
}
五、数组元素排序（冒泡排序）
/*
需求：冒泡排序
思路：
冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个
数比后一个数大（则升序，小则降序）则交换两数
*/
class ArrayTest2
{
public static void bubbleSort(int[] arr)//冒泡排序
{
for(int x=0;x<arr.length-1;x++)//控制冒泡次数
{
for(int y=0;y<arr.length-1-x;y++)//控制比较次数
{
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
public static void printArray(int[] arr)//自定义遍历一维数组函数
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}
public static void main(String[] args)
{
int[] arr={1,3,4,6,2,7,5};
System.out.print("排序前：");//排序前
printArray(arr);//调用打印函数
System.out.print("\n排序后：");//排序后
bubbleSort(arr);//调用冒泡排序函数
printArray(arr);//排序后
}
}
六、数组元素排序（位置置换功能抽取）
发现无论什么排序。都需要对满足条件的元素进行位置置换，所以可以把这部分代码提取出来，单独封装成一个函数。
/*
需求：冒泡排序
思路：
冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个
数比后一个数大（则升序，小则降序）则交换两数
*/
class ArrayTest2
{
public static void bubbleSort(int[] arr)//冒泡排序
{
for(int x=0;x<arr.length-1;x++)//控制冒泡次数
{
for(int y=0;y<arr.length-1-x;y++)//控制比较次数
{
if(arr[y]>arr[y+1])
{
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;
}
public static void printArray(int[] arr)//自定义遍历一维数组函数
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}
public static void main(String[] args)
{
int[] arr={1,3,4,6,2,7,5};
System.out.print("排序前：");//排序前
printArray(arr);//调用打印函数
System.out.print("\n排序后：");//排序后
bubbleSort(arr);//调用冒泡排序函数
printArray(arr);//排序后
}
}
技巧：引入import java.util.*;通过Arrays.sort();也可以进行数组排序。
七、折半查找
/*
数组元素的查找操作
*/
class ArrayTest3
{
public static void main(String[] args)
{
int[] arr={2,3,4,6,8,64,78};
//int index=getIndex(arr,2);//遍历查找
//int index=halfSearch(arr,8);//折半查找方法1
int index=halfSearch_2(arr,8);//折半查找方法2
System.out.println("index="+index);
}
//折半查找，前提是数组元素是有序的。
public static int halfSearch(int[] arr,int key)//方法1
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(max+min)/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;
mid=(max+min)/2;
}
return mid;
}
public static int halfSearch_2(int[] arr,int key)//方法2
{
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;
}
//定义功能，获取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 getIndex_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 min;//返回要插入的具体位置
}
八、十进制->二进制和十进制->十六进制
/*
十进制->二进制和十进制->十六进制
*/
class ArrayTest4
{
public static void main(String[] args)
{
toBin(60);//十进制->二进制
toHex(60);//十进制->十六进制
}
public static void toBin(int num)//十进制->二进制函数
{
StringBuffer sb=new StringBuffer();
while(num>0)
{
sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());
}
public static void toHex(int num)//十进制->十六进制函数
{
StringBuffer sb=new StringBuffer();
for(int x=0;x<8;x++)
{
int temp=num&15;
if(temp>9)
{
sb.append((char)(temp-10+'A'));
}
else
{
sb.append(temp);
}
num=num>>>4;
}
System.out.println(sb.reverse());
}
}
九、查表法进行十进制->十六进制和十进制->二进制
/*
查表法进行十进制->十六进制和十进制->二进制
*/
class ArrayTest5
{
public static void main(String[] args)
{
toHex(60);
toBin(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后的值作为索引去查建立好的表，就可以找到对应的元素。
可以通过数组的形式去定义。
*/
public static void toHex(int num)//查表法16进制
{
char[] chs={'0','1','2','3','4',
'5','6','7','8','9',
'A','B','C','D','E','F'
};//定义二进制表
char[] arr=new char[8];//定义一个临时存储容器，元素默认值'\u0000'。
int pos=arr.length;
while(num!=0)
{
int temp=num&15;
arr[--pos]=chs[temp];
num=num>>>4;
}
for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();//换行
}
public static void toBin(int num)//查表法2进制
{
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]);
}
System.out.println();//换行
}
}
十、进制转换优化
/*
进制转换优化
*/
class ArrayTest6
{
public static void main(String[] args)
{
toBin(-3);
toOctal(30);
toHex(-20);
}
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];//默认值'\u0000'
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();//换行
}
}
十一、 二维数组
(其实是一个一维数组，它的每一个元素又是一个一维数组)
int[][] i1 = new int[2][3];
int[][] i4 = {{1,1,1},{2,2,2},{3,3,3}};
int[][] i3 = new int[][3]; //不允许高维没分配空间而先给低维分配空间
int[][] i2 = new int[2][];
i2[0] = new int[2];
i2[1] = new int[3];
注意：
int[] x,int x[];//一维
int[][]y;int y[][]; int[] y[];//二维
int[] x,y[];//x一维，y二维
也就是：
int[] x;
int[] y[];
1.x[0]=y;//error
2.y[0]=x;//yes
3.y[0][0]=x;//error
4.x[0][0]=y;//error
5.y[0][0]=x[0];//yes
6.x=y;//error
练习：
/*
二维数组遍历
*/
class ArrayTest7
{
public static void main(String[] args)
{
int a[][]=new int[][]{{1},{1,2},{1,2,3},{1,2,3,4}};//定义二维数组
for(int i=0;i<a.length;i++)
{ for(int j=0;j<a[i].length;j++)
{
System.out.print(a[i][j]);
}
System.out.println();//换行
}
}
}
396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
