5数组容器综合应用
导语:
想写在写
- 将数组转成字符串](#ArrayTest3)
- 查表法,星期示例
- 十六进制转换,解决了顺序反的问题。使用的数组
- 十六进制转换,解决了去零问题
- 十六进制转换,使用了查表法
- 三种进制转换,通用版。综合练习。★★★★★
- 选择和冒泡排序
- 普通查找和二分查找
- 二维数组演示,要画图
- 二维数组的求和
- 数组的反转。有序数组的插入点
1. 将数组转成字符串
class ArrayTest3
{
public static void main(String[] args)
{
int[] arr = {34,12,56,90};
String str = toString(arr);
System.out.println(str);
}
/*
需求1:定义功能,将{34,12,67}数组中的元素转成字符串 "[34,12,67]"
明确1:结果?字符串。
明确2:参数?数组。
思路:
简单的方式就是利用了字符串和任何数据相加都是相连接。
*/
public static String toString(int[] arr)
{
//1,定义字符串变量。
String temp = "[";
//2,遍历数组。将每一个数组的元素和字符串相连接。
for(int x = 0; x < arr.length; x++)
{
//判断,不是最后一个元素,后面连接逗号,是最后一个元素,后面不连接逗号。
if(x!=arr.length-1)
temp = temp + arr[x] + ",";
else
temp = temp + arr[x] + "]";
}
//3,将连接后的字符串返回。哦耶!
return temp;
}
}
2. 查表法,星期示例
class ArrayTest4
{
public static void main(String[] args)
{
}
/*
数组使用的核心思想:
容器特点:1,固定长度,2,元素都有索引。
什么时候使用容器呢?数据多了,必须先进行存储。然后进行操作。
对于数组容器什么时候用呢?数据多,个数确定,而且有对应关系。
在分析需求时,
1,需求中的数据是否有对应的有序编号?
2,需求中的数据是否需要有序的编号?
如果有,就用数组存储。
例1:一组数:34 89 12 78 45 要对他们进行操作。需要编号,操作更容易。
例2:根据用户输入的数据,显示对应的星期。
思路:
1,星期有多个,个数固定。
2,星期对应的有序编号。有序的编号就可以作为索引。
所以可以使用数组这种结构进行存储。
*/
/*
定义一个功能。根据给定的数据获取对应的星期。
查表法:数据之间存在对应关系。通过关系中一方查询另一方。当对应关系存在,但没有一方是有序编号时,使用另一个容器 map。
*/
public static String getWeek(int num)
{
if(num>7 || num<1)
return num+"没有对应的星期";//throw new RuntimeExcpetion(num+"没有对应的星期");
//1,定义一个数组,存储固定的星期数。这个称之为一个存储了对应关系的表。
String[] weeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
//其实就是根据制定的索引在查表。
return weeks[num];
}
}
3. 十六进制转换,解决了顺序反的问题。使用的数组
class ArrayTest5
{
public static void main(String[] args)
{
int num = 60;
String str_hex = toHex(num);
System.out.println(str_hex);
}
/*
需求:十进制-->十六进制。
&15 >>>4 循环
遇到问题:
1,顺序反了。2,去除多余的0.
解决方式:
1,每运算出一位,不要打印,先存储。需要容器。
*/
public static String toHex(int num)
{
//1,定义容器。存储的是字符,长度为8.一个整数最多8个16进制位。
char[] chs = new char[8];
//2,定义一个用于操作数组的索引。
int index = chs.length-1;
for(int x=0; x<8; x++)
{
int temp = num & 15;
if(temp > 9)
chs[index] = ((char)(temp-10+'A'));
else
chs[index] = ((char)(temp+'0'));
index--;
num = num >>> 4;
}
/*//4,遍历数组。
for(int x=0; x<chs.length; x++)
{
System.out.print(chs[x]+",");
}
*/
return "0x"+toString(chs);
}
//定义一个功能,将字符数组转成字符串。
public static String toString(char[] arr)
{
String temp = "";
for(int x=0; x<arr.length; x++)
{
temp = temp + arr[x];
}
return temp;
}
}
4. 十六进制转换,解决了去零问题
class ArrayTest6
{
public static void main(String[] args)
{
int num = 60;
String str_hex = toHex(num);
System.out.println(str_hex);
}
/*
需求:十进制-->十六进制。
&15 >>>4 循环
遇到问题:
1,顺序反了。2,去除多余的0.
解决方式:
1,每运算出一位,不要打印,先存储。需要容器。
2,去除零?需要转换的数据会不断的右移,如果右移后剩余的二进制都是0,也就是没有有效位,
就不需要进行&运算了。也就是不需要在往数组中存储了。
*/
public static String toHex(int num)
{
//1,定义容器。存储的是字符,长度为8.一个整数最多8个16进制位。
char[] chs = new char[8];
//2,定义一个用于操作数组的索引。
int index = chs.length;
while(num!=0)
{
int temp = num & 15;
if(temp > 9)
chs[--index] = ((char)(temp-10+'A'));
else
chs[--index] = ((char)(temp+'0'));
num = num >>> 4;
}
System.out.println("index="+index);
return "0x"+toString(chs,index);
}
//定义一个功能,将字符数组转成字符串。
public static String toString(char[] arr,int index)
{
String temp = "";
for(int x=index; x<arr.length; x++)
{
temp = temp + arr[x];
}
return temp;
}
}
5. 十六进制转换,使用了查表法
class ArrayTest7
{
public static void main(String[] args)
{
int num = 26;
String str_hex = toHex(num);
System.out.println("hex:"+str_hex);
}
/*
需求;十进制-->十六进制,终结版。
思路:
十进制转成十六进制的每一位都是十六进制元素中的某一个。
十六进制的元素有很多固定个数。而且还有对应的编号。
所以可以使用传说中的 查表法!
*/
public static String toHex(int num)
{
//1,建立表。
char[] chs = {'0','1','2','3'
,'4','5','6','7'
,'8','9','A','B'
,'C','D','E','F'};
//2,创建临时容器。
char[] arr = new char[8];
//3,创建操作临时容器的角标。
int index = arr.length;
//4,通过循环对num进行& >>等运算。
while(num!=0)
{
//5,对num进行&运算。
int temp = num & 15;
//6,根据&运算后的结果作为角标查表,获取对应的字符。并将字符存储到临时容器中。
arr[--index] = chs[temp];
//7,对num进行右移。
num = num >>> 4;
}
return "0x"+toString(arr,index);
}
//定义一个功能,将字符数组转成字符串。
public static String toString(char[] arr,int index)
{
String temp = "";
for(int x=index; x<arr.length; x++)
{
temp = temp + arr[x];
}
return temp;
}
}
6. 三种进制转换,通用版。综合练习。★★★★★
class ArrayTest8
{
public static void main(String[] args)
{
int num = 60;
String str_bin = toBinary(num);
String str_oct = toOctal(num);
String str_hex = toHex(num);
System.out.println("bin:"+str_bin);
System.out.println("oct:"+str_oct);
System.out.println("hex:"+str_hex);
//Java已经提供的功能。
System.out.println(Integer.toBinaryString(60));
System.out.println(Integer.toOctalString(60));
System.out.println(Integer.toHexString(60));
}
/*
十进制-->十六进制。
*/
public static String toHex(int num)
{
return "0x"+trans(num,15,4);
}
/*
十进制-->二进制。
*/
public static String toBinary(int num)
{
return trans(num,1,1);
}
/*
十进制-->八进制。
*/
public static String toOctal(int num)
{
return "0"+trans(num,7,3);
}
//用于进制转换。
public static String trans(int num,int base,int offset)
{
if(num==0)
return "0";
//1,建立表。
char[] chs = {'0','1','2','3'
,'4','5','6','7'
,'8','9','A','B'
,'C','D','E','F'};
//2,创建临时容器。
char[] arr = new char[32];
//3,创建操作临时容器的角标。
int index = arr.length;
//4,通过循环对num进行& >>等运算。
while(num!=0)
{
//5,对num进行&运算。
int temp = num & base;
//6,根据&运算后的结果作为角标查表,获取对应的字符。并将字符存储到临时容器中。
arr[--index] = chs[temp];
//7,对num进行右移。
num = num >>> offset;
}
return toString(arr,index);
}
//定义一个功能,将字符数组转成字符串。
public static String toString(char[] arr,int index)
{
String temp = "";
for(int x=index; x<arr.length; x++)
{
temp = temp + arr[x];
}
return temp;
}
}
7. 选择和冒泡排序
import java.util.Arrays;
class ArrayTest9
{
public static void main(String[] args)
{
int[] arr = {12,9,23,77,6,34};
printArray(arr);
//selectSort(arr);
// bubbleSort(arr);
// Arrays.sort(arr);//开发时用这个。
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.println(arr[x]);
}
}
/*
数组的排序。
选择排序。
*/
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 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;
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;
}
}
8. 普通查找和二分查找
class ArrayTest10
{
public static void main(String[] args)
{
int[] arr = {9,12,15,24,36,41,59,68};
int index = binarySearch(arr,45);
System.out.println("index="+index);
}
//二分查找。前提:数组必须是有序的。
/*
思路:
1,通过角标先获取中间角标上元素。
2,让该元素和要找的数据比较。
3,如果要找的数大了,缩小范围,要找的范围应该是 中间的角标+1---尾角标。
如果要找的数小了,要找的范围 头角标---中间角标-1;
4,不断如此重复,就可以找到元素对应的角标。
*/
public static int binarySearch(int[] arr,int key)
{
//1,定义三个变量,记录头角标,尾角标,中间角标。
int max,min,mid;
min = 0;
max = arr.length-1;
mid = (max+min)>>1;
while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
//判断元素是否存在。
if(max<min)
return -1;
mid = (max+min)>>1;
}
return mid;
}
public static int binarySearch(int[] arr,int key)
{
//1,定义三个变量,记录头角标,尾角标,中间角标。
int max,min,mid;
min = 0;
max = arr.length-1;
while(min<=max)
{
mid = (min+max)>>1;
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
//查找。
/*
需求;查找一个元素在数组中的第一次出现的位置。
*/
public static int searchKey(int[] arr,int key)
{
//遍历查找。
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;//-1,代表的是角标不存在的情况。
}
}
9. 二维数组演示,要画图
class Array2Demo
{
public static void main(String[] args)
{
//二维数组。
/*
int[][] arr = new int[3][2];
System.out.println(arr);// [[I@e6f7d2//二维数组实体。
System.out.println(arr[0]);//[I@3e0ebb//一维数组实体。
System.out.println(arr[0][0]);//0 一维数组中的元素。
*/
//
int[][] array = new int[3][];//明确了二维数组的长度,没有明确具体的一维数组。
System.out.println(array);//[[I@3e0ebb
System.out.println(array[0]);//null
System.out.println(array[0][0]);//NullPointerException
}
}
10. 二维数组的求和
class Array2Demo2
{
public static void main(String[] args)
{
/*
二维数组的另一种定义方式。
*/
int[][] arr = {{23,17,11},{88,11,33,90},{11,78,34}};
//求和。
int sum = 0;
for(int x=0; x<arr.length; x++)//遍历二维数组
{
for(int y=0; y<arr[x].length; y++)
{
sum+=arr[x][y];
}
}
System.out.println("sum="+sum);
}
}
11. 数组的反转。有序数组的插入点
/*
前五天,阶段要点:
path classpath配置
常见的编译错误提示。以及解决办法。
-------
++
&,&&的区别。
位运算 & >>>
循环嵌套。相关练习,一定要写思路。
函数的两个明确。
数组,查表法的应用。
数组的常见的应用和操作编程题一定要练。
画图:
1,函数调用的执行流程。
2,数组在内存中的分布。
3,理解题,栈,堆的特点。
阶段综合练习:进制转换。
*/
import java.util.Arrays;
class Test
{
public static void main(String[] args)
{
int[] arr = {9,13,17,22,31,46,58,77};
int index = binarySearch(arr,7);
int index2 = Arrays.binarySearch(arr,7);
System.out.println("index="+index);
System.out.println("index2="+index2);
}
/*
对一个给定的数组进行反转。
{23,14,88,5} ->
{5,88,14,23}
*/
public static void reverse(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 a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/*
思考题!
需求:如果往有序的数组中插入一个元素并继续保证有序,问如何获取该位置?
思路:
1,既然是有序的数组,而且是找位置,必须要想到 二分查找法。
*/
public static int binarySearch(int[] arr,int key)
{
int max,min,mid;
min = 0;
max = arr.length-1;
while(min<=max)
{
mid = (min+max)>>1;
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -(1+min);
}
}