Day04 Java语言基础组成——数组
Day04 Java语言基础组成
2.8 数组
数组的定义
概念：同一种类型数据的集合，其中数组就是一个容器。
数组的好处：可以自动给定数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[ ] 数组名 = new 元素类型[元素个数或数组长度]；
实例：int [ ] arr = new int[5];
格式2：创建一个数组实体，并给实体中的每一个元素定义了具体元素，数据在明确时使用。
元素类型[ ] 数组名 = new 元素类型[ ]{元素，元素，…};
int [ ] arr = new int [ ]{2,5,4,7};
int [ ] arr = {3,5,7,9};
数组的内存分配及特点
数组内存结构
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存：用于储存局部变量，当数据使用完，所占空间会自动释放。
堆内存：数组和对象，通过new建立的实力都会放在堆内存中。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值。int默认:0; double:0.0; float:0.0f; boolean:false
实体不再被使用，会在不确定的时间内被垃圾回收器回收。
方法区，本地方法区，寄存器
引用数据：两个引用数据指向同一个实体，没有数据沉余。
y 新的new，有数据沉余。
数组操作常见问题
编译时不报错，编译只检查语法错误，编译时还没有完全建立数组，在运行时才会在堆内存中开辟数组空间并分配0，1，2这3个脚标，在运行时查找3号脚标时发现没有3号脚标出现问题报错。
ArrayIndexOutOfBoundsException：3 数组脚标越界异常，提示找不到脚标3，操作数组时，访问到了数组中不存在的脚标。
NullPointerExceotion：空指针异常：当引用没任何指向值为null的情况，该引用还在用于操作实体。arr = null已经不再指向任何数组实体了，无法操作arr[1]
数组常见操作
获取数组中的元素，通常会用到遍历。
int [] arr = new int[3];
获取脚标0的元素：
System.out.println(arr[0]);
System.out.println(“arr[”+0+"]="+arr[0]+";");//arr[0]=0;
for(int x = 0; x<3 ;x++)
{
System.out.println(“arr[”+x+"]="+arr[x]+";");
}
int [] arr = {3,6,4,8,9,4};
//数组中有一个属性可以直接获取到数组元素个数 length。使用方式：数组名称.length =
System.out.println(“length”+arr.length);
for(int x = 0; x
System.out.println(“arr[”+x+"]="+arr[x]+";");
}
有数组，通常用到for循环
定义功能，用于打印数组中的元素，元素间用逗号隔开。
public static void main(String[] args)
{
int[] arr = {3,6,8,5,9,4};
printArray(arr);
}
public static void printArray(int [] arr)
{
System.out.print("[");
for (int x = 0; x[3,6,8,5,9,4]
打印了数组实体的引用 [ 数组，I int型数据，数组中元素类型，de6ced 数组的内存存放地址，16进制。
练习
获取最值
给定一个数组{5,1,6,4,2,8,9}。获取数组中的最大值，以及最小值。
思路：1.获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定，通过一个变量进行存储。
2.让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该变量记录较大值。
3.当所有的元素都进行比较完成，那么该变量中存储的就是数组中的最大值了。
步骤：1.定义变量，初始化为数组中任意一个元素即可。
2.通过循环语句中数组进行遍历。
3.在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量。
需要定义一个功能来完成，以便提高复用性。
1.明确结果，数组中的最大元素 int。
2.位置内容：一个数组。int[]
public static void main(String[] args)
{
int[] arr = {3,6,8,5,9,4};
int max = getMax(arr);
System.out.println("max = "+max);
}
public static int getMax(int [] arr)
{
int max = arr[0];
for (int x = 1; xmax)
max = arr[x];
}
return max;
}
获取最大值的另一种方式。
可不可以将临时变量初始化为0呢？可以，这种方式是在初始化为数组中的任意一个脚标。
public static void main(String[] args)
{
int[] arr = {3,6,8,5,9,4};
int max = getMax_2(arr);
System.out.println("max = "+max);
}
public static int getMax_2(int [] arr)
{
int max = 0;
for (int x = 1; xarr[max])
max = x;
}
return arr[max];
}
//获取double类型数组的最大值，因为功能一致，所以定义相同函数名称，已重载形式保存。
public static double getMax(double[] arr)
{......}
boolean型的数组的默认值为false
排序-选择排序最小的数跑到最前面。
对给定数组进行排序{5，1，6，4，2，8，9}。
大圈套小圈，嵌套循环。
%%%%%
%%%%
%%%
%%
%
指向一个数组，进行排序，从始至终只有一个数组实体，有多个引用对其进行操作。
public static void main(String[] args)
{
int[] arr = {3,6,8,5,9,4};
//排序前
printArray(arr);
//排序
selectSort(arr);
//排序后
printArray(arr);
}
public static void selectSort(int [] arr)
{
for (int x = 0; xarr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
public static void printArray(int [] arr)
{
System.out.print("[");
for (int x = 0; x 冒泡排序最大的数跑到最后面依次参与比较的元素每轮少1。
public static void bubbleSort(int [] arr)
{
for (int x = 0; x0; x--)
{ //for (int y = 0 ; yarr[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)//给a和b换位置，arr也是传输进来比较的，也不确定，所以有三个参数。
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序要使用该句代码。
数组的查找操作
public static void main(String[] args)
{
int [] arr = {3,1,2,5,6,8,2,4,9};
int index = getIndex(arr,6);
System.out.println("index = "+index);
}
//定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。
public static int getIndex(int [] arr,int key)
{
for (int x = 0; x折半查找，提高效率，但是必须要保证该数组是有序的数组。
public static void main(String[] args)
{
int [] arr = {2,4,5,7,19,32,45};
int index = halfSearch(arr,320);
System.out.println("index = "+index);
}
public static int halfSearch(int [] arr,int key)
{
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(keymax)
return -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;//同 (max+min)/2
if(key>arr[mid])
min = mid + 1;
else if(key练习
有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的。如何获取该元素在数组中的位置。
public static int getIndex_2(int arr [] ,int key)
{
int min = 0,max = arr.length-1,mid;
while(min<=max)
{
mid = (max+min)>>1;//同 (max+min)/2
if(key>arr[mid])
min = mid + 1;
else if(key如果是数组中存在的数字，把8放在数组中8要插入的位置上，后面顺延；不存在，返回的min就是8应该插入的位置。
进制转换
十进制–>二进制
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer();//先存
while(num>0)
{
//System.out.println(num%2);
sb.append(num%2);
num = num/2;
}
System.out.println(sb.reverse());//再反转打印
}
十进制–>十六进制
public static void main(String[] args)
{
toHex(60);
}
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for (int x = 0; x<8 ; x++)
{
int temp = num & 15;
if(temp > 9)
//System.out.println((char)(temp - 10 + 'A'));
sb.append((char)(temp - 10 + 'A'));
else
//System.out.println(temp);
sb.append(temp);
num = num >>> 4;
}
System.out.println(sb.reverse());
}
查表法
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 main(String[] args)
{
toHex1(-60);
}
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for (int x = 0; x<8 ; x++)
{
int temp = num & 15;
if(temp > 9)
//System.out.println((char)(temp - 10 + 'A'));
sb.append((char)(temp - 10 + 'A'));
else
//System.out.println(temp);
sb.append(temp);
num = num >>> 4;
}
System.out.println(sb.reverse());
}
public static void toHex1(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];
//字符数组在内存中一被定义它的默认初始化值为'\u0000'-->空位，空格
//int pos = 0;
int pos = arr.length ;//-->倒着存
//for (int x = 0; x<8 ; x++)
while(num != 0)
{
int temp = num & 15;
//System.out.println(chs[temp]);
//arr[x] = chs[temp];
//arr[pos++] = chs[temp];
arr[--pos] = chs[temp];
num = num >>> 4;
}
System.out.println("pos = " + pos);
//存储数据的arr数组遍历
//for (int x = 0 ; x=0 ; x--)
//for (int x = pos - 1; x>=0 ; x--)
for (int x = pos ; x倒着存
{
System.out.print(arr[x] + ",");
}
}
用查表法十进制–>二进制
public static void toBin(int num)
{
//定义二进制的表
char[] chs = {'0','1'};
//定义一个临时存储容器
char[] arr = new char[32];//一个整数32个二进制位，long 64
//定义一个操作数组的指针
int pos = arr.length;
while(num != 0)
{
int temp = num & 1;
arr[--pos] = chs[temp];
num = num >>> 1;
}
for (int x = pos ; x两者的共性，优化
public static void main(String[] args)
{
//toBin(6);
//toHex(60);
toBa(60);
}
/*
十进制-->二进制
*/
public static void toBin(int num)
{
trans(num,1,1);
}
/*
十进制-->八进制
*/
public static void toBa(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)
//num 传进来的参数，base 与上的数，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数组中的数组 二维数组 [ ] [ ]
格式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] = new int[1];
arr[2] = new int[2];
System.out.println(arr.length);//打印二维数组的长度 3
System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度
int[][] arr={{2,3,5,6},{6,3,8,9}.{6,7,2,8}};
int sum = 0;
for (int x = 0;x