元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
需求:想定义一个可以存储3个整数的容器。
int[] x = new int[3];
打印数组中角标为0的元素的值。
System.out.println(x[0]);
class ArrayDemo2
{
public static void main(String[] args)
{
int[] arr=new int[3];
//int arr[]=new int[]{234,32,29,34};
//int arr[]={23,32,98};
//System.out.println(arr[3]);
//错误:ArrayIndexOutOfBoundsException:3
//操作数组时,访问到了数组中不存在的角标
arr=null;
System.out.println(arr[1]);
//NullPointerException:空指针异常
//当引用没有任何指向,值为null的情况,该引用还在用于操作实体
}
}
class ArrayDemo3
{
public static void main(String[] args)
{
数组的操作:
获取数组中的元素,通常会用到遍历
数组中有一个属性可以直接获取到数组元素个数
使用方式:数组名称.length
System.out.println("length:"+arr.length);
需求:求数组中的元素的和
求和思想
int sum=0;
for (int x=0;x<arr.length ;x++ )
{
sum+=arr[x];
}
System.out.println("sum="+sum);
需求:遍历数组,打印数组中的每个数
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]+"]");
}
}
}
需求:给定一个数组,判断数组元素中的最大值和最小值
class ArrayTest
{
获取数组中的最大值
思路:
1、获取最值需要进行比较,每一次比较都会有一个较大的值。因为该值不确定,通过一个变量进行临时存储。
2、让数组中的每一个元素都和这个变量中的值进行比较
如果大于了变量中的值,就用该变量记录较大值
3、当所有的元素都比较完成,那么该变量中存储的就是数组中的最大值了。
步骤:
1、定义一个变量,初始化为数组中的任意一个值
2、通过循环语句对数组进行遍历
3、在变量过程中定义判断条件,如果遍历到的元素比变量中的元素大,就赋值给该变量。
需要定义一个功能来完成,以便提高复用性
1、明确结果,数组中的最大元素,返回类型int
2、未知内容参与运算:一个数组 int[] arr
public static int getMax(int[] arr)
{
int max=0;//int max=arr[0];
获取最大值的两种方式
初始化为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[]={34,12,32,97,34,2,99};
int max=getMax(arr);
int min=getMin(arr);
System.out.println("max="+max);
System.out.println("min="+min);
}
}
需求:对指定的数组进行排序
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])
{
swap(arr,x,y);
}
}
}
}
冒泡排序
public static void bubbleSort(int[] arr)
{
for (int x=0;x<arr.length-1 ;x++ )
{
for (int y=0;y<arr.length-x-1 ;y++ )//-x是让每一次比较的元素减少;-1避免角标越界
{
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 main(String[] args)
{
int[] arr={2,1,0,3,8};
print(arr);
//selectSort(arr);
bubbleSort(arr);
print(arr);
}
public static void print(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]+"]");
}
}
}
对给定的数组进行反转
class ArrayTest3
{
public static void main(String[] args)
{
int arr[]={23,123,45,97,32,34};
print(arr);
reverseArray(arr);
print(arr);
}
public static void print(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 reverseArray(int[] arr)
{
for (int start=0,end=arr.length-1;start<end ;start++,end-- )
{
swap(arr,start,end);
}
}
public static void swap(int[]arr,int x,int y)
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
数组的查找功能
需求:有一个有序的数组想要讲一个元素插入到该数组中,
还要保证该数组是有序的,如何获取该元素在数组长的位置
class ArrayTest4
{
定义功能,获取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 void main(String[] args)
{
int[] arr={12,23,31,34};
int index=getIndex(arr,9);
//查找位置
System.out.println(index);
//查找位置,如果没有,返回放入该数组中的位置
System.out.println(halfSearch(arr,34));
//查找位置,如果没有,返回放入该数组中的位置
System.out.println(halfSearch_2(arr,26));
}
public static void print(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 int halfSearch(int[] arr,int key)
{
int max=arr.length-1,min=0,mid;
while(min<=max)
{
mid=(max+min)/2;
if(arr[mid]>key)
max=mid-1;
else if(arr[mid]<key)
min=mid+1;
else
return mid;
}
return min;
}
折半查找的第二种方式
public static int halfSearch_2(int[] arr,int key)
{
int max,min,mid;
max=arr.length-1;
min=0;
mid=(max+min)/2;
while (arr[mid]!=key)
{
if(arr[mid]<key)
min=mid+1;
else if(arr[mid]>key)
max=mid-1;
if(min>max)
return min;
mid=(max+min)/2;
}
return mid;
}
}
class ArrayTest5
{
public static void main(String[] args)
{
toBin(6);
toHex(60);
}
十进制转二进制
public static void toBin(int num)
{
while (num>0)
{
System.out.println(num%2);
num=num/2;
}
}
十进制转十六进制
public static void toHex(int num)
{
StringBuffer sb=new StringBuffer();
for (int x=0;x<8 ;x++ )//int数据类型占用4个字节,4位移动一次,最多移动8次
{
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());
}
}
class ArrayTest6
{
public static void main(String[] args)
{
toHex(60);
toBin(6);
}
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'简单多了
这个表怎么建立呢?
可以通过数组的形式来定义
结果是反着的,想要正过来,可以通过遍历数组
,从最后一位遍历。
public static void toHex(int num)
{
char[] ch={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] arr=new char[8];//循环8次,最多有8个数
//字符串数组默认'\u0000'代表空格
int pos=arr.length;//定义指针
while (num!=0)
{
int temp=num&15;
arr[--pos]=ch[temp];
num=num>>>4;
}
System.out.println("pos="+pos);
存储数据的arr数组遍历
System.out.print("[");
for (int x=pos; x<arr.length;x++ )
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
public static void toBin(int num)
{
定义一个二进制的表
char[] ch={'0','1'};
定义一个存储的数组
char[] arr=new char[32];
定义一个指针
int pos=arr.length;
while (num!=0)
{
int temp=num&1;
arr[--pos]=ch[temp];
num=num>>>1;
}
System.out.println("pos="+pos);
//存储数据的arr数组遍历
System.out.print("[");
for (int x=pos; x<arr.length;x++ )
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
优化
class ArrayTest7
{
public static void main(String[] args)
{
toBin(6);
System.out.println();
toHex(60);
System.out.println();
toBa(34);
System.out.println();
}
//十进制转二进制
public static void toBin(int num)
{
trans(num,1,1);
}
//十进制转十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
//十进制转八进制
public static void toBa(int num)
{
trans(num,7,3);
}
public static void trans(int num,int base,int offset)
{
if(num==0)
System.out.println(0);
char[] ch={'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]=ch[temp];
num=num>>>offset;
}
for (int x=pos; x<arr.length;x++ )
{
System.out.print(arr[x]);
}
}
}
class Array2Demo
{
public static void main(String[] args)
{
int[][] arr=new int[2][5];//定义了名称为arr的二维数组。
该二维数组中有2个一维数组,每个一位数组中有5个元素
System.out.println(arr);//[[I@de6ced 二维数组的地址值
System.out.println(arr[0]);//[I@c17164 一维数组的地址值
System.out.println(arr[0][0]);//二维数组中第一个一维数组第一个元素的值
System.out.println(arr.length);//二维数组的长度2
System.out.println(arr[0].length);//第一个一维数组的长度
int arr[][]={{12,23,4,2,5},{122,223,34,24,15}};
getSum(arr);
}
需求:计算二维数组中元素的和
public static void getSum(int[][] arr)
{
int sum=0;
for (int a=0;a<arr.length ;a++ )
{
for (int b=0;b<arr[a].length ;b++ )
{
sum=sum+arr[a][b];
}
}
System.out.println(sum);//打印和
}
}