5数组容器综合应用
导语：
想写在写
- 将数组转成字符串
- 查表法，星期示例
- 十六进制转换，解决了顺序反的问题。使用的数组
- 十六进制转换，解决了去零问题
- 十六进制转换，使用了查表法
- 三种进制转换，通用版。综合练习。★★★★★
- 选择和冒泡排序
- 普通查找和二分查找
- 二维数组演示，要画图
- 二维数组的求和
- 数组的反转。有序数组的插入点
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);
}
}
2881
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
