Day-4
1.数组(静态初始化,常见问题)
2.数组(常见操作-遍历)
class ArrayDemo3
{
<span style="white-space:pre"> </span>public static void main(String[] arg)
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>//数组的操作:
<span style="white-space:pre"> </span>//获取数组中的元素.通常会用到遍历.
<span style="white-space:pre"> </span>//
<span style="white-space:pre"> </span>//int [] arr = new int[3];
<span style="white-space:pre"> </span>int [] arr = {3,6,5,1,8,9,68};
<span style="white-space:pre"> </span>//数组中有一个属性可以直接获取到数组元素个数,length.
<span style="white-space:pre"> </span>//使用方式:数组名称.length =
<span style="white-space:pre"> </span>//System.out.println("length:"+arr.length);
<span style="white-space:pre"> </span>//int sum = 0;
<span style="white-space:pre"> </span>/*
<span style="white-space:pre"> </span>for(int x=0; x<arr.length; x++)
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>//sum += arr[x];
<span style="white-space:pre"> </span>System.out.println("arr["+x+"]="+arr[x]+";");//arr[0]=0;
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>*/
<span style="white-space:pre"> </span>System.out.println(arr);
<span style="white-space:pre"> </span>printArray(arr);
<span style="white-space:pre"> </span>//printArray(arr);
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>//定义功能,用于打印数组中的元素,元素间用逗号隔开.
<span style="white-space:pre"> </span>public static void printArray(int[] arr)
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>System.out.print("[");
<span style="white-space:pre"> </span>for(int x =0; x<arr.length; x++)
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>if(x!=arr.length-1)
<span style="white-space:pre"> </span>System.out.print(arr[x]+",");
<span style="white-space:pre"> </span>else
<span style="white-space:pre"> </span>System.out.println(arr[x]+"]");
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>}
}
3.数组(常见操作-获取最值)
/*
给定一个数组{5,1,6,4,2,8,9}.
1,获取数组中的最大值,以及最小值.
*/
class ArrayTest
{
/*
获取数组中的最大值
思路:
1,获取最值需要进行比较.每一次比较都会有一个较大的值,因为该值不确定
通过一个变量进行临时存储.
2,让数组中的每一个元素都和这个变量中的值进行比较
如果大于了变量中的值,就用该该变量记录较大值.
3,当所有的元素都比较完成,那么该变量中存储的就是数组中的最大值了
步骤:
1,定义变量,初始化为数组中的任意一个元素接口
2,通过循环语句对数组进行遍历
3,在遍历过程中定义判断条件,如果遍历到的元素比变量中的元素大,就赋值给该变量
需要定义一个功能来完成,以便提高复用性.
1,明确结果,数组中的最大元素 int.
2,未知内容:一个数组,int[]
*/
public static int getMax(int [] arr)
{
int max = arr[0];
for(int x =1; x<arr.length;x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}
/*
获取最大值的另一种方式.
可以不可以将临时变量初始化为0呢?
可以,这种方式,其实是在初始化为数组中的角标
*/
public static int getMax_2(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=0;x<arr.length;x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
//获取double类型数组的最大值,因为功能一致,所以定义相同函数名称,以重载形式存在
//public static double getMax(double[] arr)
public static void main(String[] args)
{
int[] arr ={5,1,6,4,2,8,9};
int max = getMax_2(arr);
int min = getMin(arr);
System.out.println("max="+max);
System.out.println("min="+min);
//boolean[] ar =new boolean[3];
//System.out.println(ar[0]);
}
}
4.数组(排序-选择排序)
选择排序
0 1 2 3 4 5 角标
3 1 4 2 7 5
3和1 如果3比1大 把小的(1)往前放
1 3 4 2 7 5
1和4 如果4比1大 把小的(1)往前放
/*
对给定数组进行排序
{5,1,6,4,2,8,9}
*/
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 main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
//在排序前打印;
printArray(arr);
//排序
selectSort(arr);
//在排序后打印
printArray(arr);
}
public static void printArray(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]+"]");
}
}
}
5.数组(冒泡排序)
import java.util.*;
/*
对给定数组进行排序
{5,1,6,4,2,8,9}
*/
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 bubbleSort(int [] arr)
{
for(int x=0; x<arr.length-1;x++)//for(int x=arr.length-1;x>0;x++)
{//for(int y=0; y<x;y++)
for(int y=0; y<arr.length-x-1;y++)//-x:让每一次比较的元素减少,-1,避免角标越界
{
if(arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
//在排序前打印;
printArray(arr);
//排序
//selectSort(arr);
//bubbleSort(arr);
Arrays.sort(arr);//Java调用
//在排序后打印
printArray(arr);
}
public static void printArray(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]+"]");
}
}
}
6.数组(排序-位置置换功能抽取)
7.数组(折半查询)
/*
数组的查找操作
练习:有一个有序的数组,想要将一个元素插入到该数组中,还要保证该数组是有序的
*/
class ArrayTest4
{
public static void main(String[] args)
{
//int[] arr = {3,1,5,4,2,9};
//int index =getIndex(arr,2);
//System.out.println("index="+index);
int[] arr = {1,3,5,14,21,39};
int index = getIndex_2(arr,8);
System.out.println("index="+index);
}
public static int getIndex_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid;
while (min <= max)
{
mid = (max+min)>>1;//5>>1 5/2
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return min;
}
/*
折半的第二种方式.
*/
public static int halfSearch_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid;
while (min <= max)
{
mid = (max+min)>>1;//5>>1 5/2
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
/*
折半查找,提高效率,但是必须要保证该书组是有序的数组
*/
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(key <arr[mid])
max = mid -1;
if(min >max)
return -1;
mid = (max+min)/2;
}
return mid;
}
//定义功能,获取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;
}
}
8.数组(十进制-二进制)
class ArrayTest5
{
public static void main(String[] args)
{
toBin(6);
}
/*
十进制→二进制
*/
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());
}
}
9.数组(十进制-十六进制)
十进制60转十六进制
0000-0000 0000-0000 0000-0000 0011-1100 60
&0000-0000 0000-0000 0000-0000 0000-1111 15
-----------------------------------------------------------
00-1100 =12 →c
0000-0000 0000-0000 0000-0000 0011 >>>
&0000-0000 0000-0000 0000-0000 0000-1111 15
---------------------------------------------------------------
0011 = 3
60→3C
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());
}
10.数组(查表法-十进制 十六进制)
class ArrayTest6
{
public static void main(String[] args)
{
toHex(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 11 12 13 14 15 16
查表法:将所有的元素临时存数起来,简历对应关系.
每一次&15后的值作为索引去查建立好的表,就可以找对应的元素.
这样比-10+'a'简单的多.
这个表怎么建立呢?
可以通过数据的形式来定义.
发现终于出结果了.但是是反着的,想要正过来呢?可以通过StringBuffer reverser功能来完成,但是这个工具还没有学习
所以可以使用已经学习过的容器:数组来完成存储
*/
public static void toHex(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];
int pos = arr.length;
while(num!=0)
{
int temp = num & 15;
//System.out.println(chs[temp]);
arr[--pos] = chs[temp];
num = num >>> 4;
}
//存储数据的arr数组遍历.
System.out.println("pos="+pos);
//存储数据的arr数组遍历.
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]+",");
}
}
}
11.数组(查表法,十进制,二进制)
public static void main(String[] args)
{
//toHex(60);
toBin(6);
}
public static void toBin(int num)
{
//定义二进制的表
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.println(pos+"---"+arr.length);
System.out.print(arr[x]);
}
}
12.数组(进制转换优化)
class ArrayTest7
{
public static void main(String[] args)
{
toBin(6);
toBa(60);
toHex(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)
{
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<arr.length;x++)
{
System.out.print(arr[x]);
}
}
}
13.数组(二维数组)
class Array2Demo
{
public static void main(String[] args)
{
//int[][] arr = new int[3][4];//定义了名称为arr的二维数组,二维数组中有3个一堆数组
//每一个一维数组中有4个元素
//System.out.println(arr[0][1]);
/*
int[][] arr = new int[3][];
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 = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int sum =0;
for(int x=0; x<arr.length;x++)
{
for(int y=0; y<arr[x].length;y++)
{
sum = sum +arr[x][y];
}
}
System.out.println("sum="+sum);
}
}
14.数组(二维数组练习)
/*
int[] x; int x[];
int[][] y; int y[][]; int[]y[];
int[] x,y[];x一维,y二维.
int[] x;
int[] y[];
a.
x[0] =y;//error
b.
y[0] = x;//yes
c.
y[0][0] = x;//error
d.
x[0][0] = y;//error
e.
y[0][0] = x[0];//yes
f.
x=y;//error
*/
添加好友
小额赞助
| 微信 | 支付宝 |
| | |
| | |
| | |
| | |
| | |
401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
