Java基础
Java编程基础
1、数组(常见问题----静态初始化)
Eg:
int []arr = new int [] {1,3,6,5,4}; //定义了一个名为arr的整数数组,同时初始化
或 int []arr1 = {1,3,6,5,4}; //定有了一个名为arr1的整数数组,并初始化
或 int []arr2 = new int [3]; //定义了一个名为arr2的整数数组,并开辟了3个整数空间
System.out.println(arr[2]); //调用并输出arr数组。若角标越界,会有错误提示。
2、数组(常见操作----遍历)
数组操作
//获取数组中的元素,通常会用到遍历
for(int x = 0 ; x < 3 ; x++)
{
System.out.println("arr["+x+"]="+arr[x]);
}
//int []arr = new int [] {1,3,6,5,4};
输出结果:
arr[0]=1
arr[1]=3
arr[2]=6
-
/*
* 数组中有一个属性可以直接获取到数组元素个数(数组名.length)
* 使用方式:数组名称.length ;
*/
//数组中属性length使用方法
for(int x = 0 ; x < arr.length ; x++)
{
System.out.println("arr["+x+"]="+arr[x]);
}
//int []arr = new int [] {1,3,6,5,4};
输出结果:
arr[1]=3
arr[2]=6
arr[3]=5
arr[4]=4
3、数组(常见操作----获取最值)
给定一个数组{5,1,6,4,2,8,9}
(1)、获取数组中的最大值,以及最小值。
思路:
1、获取最值需要进行比较,每一次比较都会有一个较大的值,因为改值不确定,所以用一个变量temp进行临时存储。
2、让数组中的每一个元素都和这个变量中的值进行比较,如果大于变量中的值,就用该变量记录较大值。
3、当所有的元素都比较完成,那么该变量中存储的就是数组中的最大值。
步骤:
1、定义变量,初始化为数组中任意一个元素即可。
2、通过循环语句对数组进行遍历
3、在遍历过程中定义判断条件,如果遍历到的元素比变量中的元素大,就赋值给该变量
4、需要定义一个功能函数来完成,以便提高复用性。
(1)、明确结果:数组中的最大元素int
(2)、未知内容:一个数组int []
代码:
class demo21
{
public static int getMax (int [] arr)
{
int max = arr[0];
for (int x = 0 ; x < arr.length ; x ++)
{
if (arr[x] > max)
{
max = arr[x];
}
}
return max ;
}
public static void main(String [] args)
{
int [] arr =new int []{5,1,6,4,2,8,9};
int max = getMax(arr);
System.out.println("Max = "+max);
}
}
输出结果: Max = 9
4、数组(排序-----选择排序)
选择排序:内循环结束一次,最值出现在头角标位置上
选择功能函数
class demo21
{
//选择功能函数
public static void selectSort(int [] arr)
{ 用双层循环去进行每一轮的元素比较
for (int x = 0 ; x< arr.length; 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 =new int []{3,1,4,2,7,5}; //初始化整数数组并赋值
//int max = getMax(arr);
for(int x = 0 ; x < arr.length; x++) //用循环结构输出原数组
{
System.out.println("arr ["+x+"]="+arr[x]);
}
System.out.println();
selectSort(arr); //调用选择功能函数selectSort
for(int x = 0 ; x < arr.length; x++) //用循环结构输出调用功能函数排序后的数组结果。
{
System.out.println("arr ["+x+"]="+arr[x]);
}
}
输出结果:
arr [0]=3
arr [1]=1
arr [2]=4
arr [3]=2
arr [4]=7
arr [5]=5
arr [0]=1
arr [1]=2
arr [2]=3
arr [3]=4
arr [4]=5
arr [5]=7
5、数组(排序----冒泡排序)
冒泡排序:相邻的两个元素进行比较,如果符合条件则换位。
如图:
第一轮:最值出现了最后位
//功能函数代码:
class demo21
{
//冒泡排序
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 ++) //内循环控制的是元素间的比较,
{
if(arr[y+1]<arr[y])
{
int temp;
temp = arr[y];
arr[y]=arr[y+1] ;
arr[y+1] = temp;
}
}
}
}
public static void main(String [] args)
{
int [] arr =new int []{3,1,4,2,6}; //初始化整数数组并赋值
for(int x = 0 ; x < arr.length; x++) //用循环结构输出原数组
{
System.out.println("arr ["+x+"]="+arr[x]);
}
System.out.println();
bubbleSort(arr); //调用选择功能函数bubbleSort
for(int x = 0 ; x < arr.length; x++) //用循环结构输出调用功能函数排序后的数组结果。
{
System.out.println("arr ["+x+"]="+arr[x]);
}
}
6、数组(排序----位置置换功能抽取)
/*
发现无论什么排序,都需要对满足条件的元素进行位置置换,所以可以把这部分相同的代码提取出来,单独封装成一个函数。
*/
//位置置换功能函数
public static void swap(int []arr, int a , int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
7、数组(折半查找)
//定义一个功能函数以获取数组中某元素的角标号
class demo21
{
//定义功能,获取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 =new int []{3,2,1,5,4,2,9}; //初始化整数数组并赋值
int index = getIndex (arr,3);
System.out.println("Index="+index);
}
返回结果:Index=0
折半查找法:该查找的方法适合有序的数组。
/*折半查找,提高效率,但必须是有序的数组。*/
代码:
class demo21
{
public static int halfSearch(int []arr ,int key) //功能函数折半查找法
{
int max = arr.length-1,min=0,mid = (min+max)/2; //初始化
while(arr[mid]!=key && min <= max) //直到角标找到了该值或角标min>max的时候,退出循环
{
if(arr[mid]>key)
{
max = mid - 1;
mid = (min+max)/2;
}
else if(arr[mid]<key)
{
min = mid +1;
mid = (min+max)/2;
}
}
if(min > max) //在循环时给min和max进行缩小,如果缩小到min>max时,证明key值不存在数组中,所以返回-1
{
return -1;
}
else return mid; //否则返回该值得角标号mid
}
public static void main(String [] args) //主函数调用折半查找法!
{
int [] arr = {2,4,5,7,19,32,45};
int index = halfSearch(arr,45);
if(index == -1)
{
System.out.println("数组中不存在该数");
}
else System.out.println("Index="+index);
}
折半查找法的第二种方式
class demo21
{
public static int halfSearch_2(int []arr ,int key)
{
int min = 0 , max = arr.length-1,mid = 0;
while (arr[mid] != key && min <= max)
{
mid = (max + min ) >>1; //用该方法代替mid = (min+max)/2,效率更高,其他和方法一同理
if(key > arr[mid])
{
min = mid +1;
}
else if (key < arr[mid])
{
max = mid -1;
}
}
if(min > max)
{
return -1;
}
else return mid;
}
public static void main(String [] args)
{
int [] arr = {2,4,5,7,19,32,45};
int index = halfSearch_2(arr,46);
System.out.println("Index="+index);
}
结果 Index=-1
一道面试题:在一个有序的数组中,我们想插入一个数,并保持原数组的有序性,我们怎样能得出该数在该数组中的位置。
利用折半查找法 图:
/*十进制转换成二进制*/
代码:
class demo21
{
public static void toBin(int num) //功能函数toBin将十进制数转换为二进制
{
while (num>0)
{
System.out.print(num%2); //num是十进制数,每次循环除2前都取其值的除2余数值并输出
num = num /2;
}
}
public static void main(String [] args)
{
toBin(6); //调用函数
}
}
输出结果:011
以上结果是个反向的结果!因为6的二进制的表示形式是110,即以上代码需要改进!
/*改进后的十进制转化成二进制代码,即结果的二进制表现形式是正向的。*/
class demo21
{
//改进后的toBin
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer(); // 创建一个对象StringBuffer新实体的sb,该实体可以引用对象中的append()功能
while ( num>0)
{
sb.append(num%2); //把结果011存储到append队列里
num = num/2;
}
System.out.print(sb.reverse()); //把存储在对象sb里的append队列里的结果反向输出。即输出110
}
public static void main(String [] args)
{
toBin(6); //引用函数
}
}
输出结果:110
/十进制转换成十六进制/
代码:
class demo21
{
//十进制转换成十六进制
public static void toHex(int num)
{
for(int x = 0;x<8;x++) //循环8次,目的为了把二进制的每一位(共八位)都提取出来
{
int temp = num & 15; //输入的十进制数进行与15(二进制形式1111),目的把二进制的每一位(共八位)都提取出来
if(temp > 9) //if-else是考虑到如果temp大于10的输出问题,因为十六进制10~15是用字母表示
{
System.out.print((char)(temp-10+'A'));
}
else System.out.print(temp);
num = num >>>4; //每次循环时对十进制数进制右移四位
}
}
public static void main(String [] args)
{
toHex(60); //调用函数,求60的十六进制
}
}
输出结果:C3000000
/*查表法十进制转换十六进制*/
class demo21
{
//改进后的toHex
public static void toHex(int num)
{
char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; //制表:代表到十六进制的字符都存储chs字符数组里
for(int x = 0 ; x < 8 ; x++)
{
int temp = num & 15; //与完15后的temp就相当于字符数据里的角标号
System.out.print(chs[temp]); //利用temp值去调用chs字符数组中的字符元素
num = num >>> 4;
}
}
public static void main(String [] args)
{
toHex(60);
}
}
输出结果:C3000000
但是无论是上面的/十进制转换成十六进制/还是/查表法十进制转换十六进制/,输出的结果都是一个反向的十六进制结果,如果我们需要正过来呢?可以 通过StringBuffer reverse来完成。但是这个工具我们还没学习,所以可以使用已经学习过的容器数组来存储。
/*改进后的查表法十进制转化成十六进制*/
class demo21
{
//改进后的toHex
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) //当整数右移四位后等于0,跳出,为了不让0存进arr字符数组内
{
int temp = num & 15;
arr[--pos] = chs[temp]; //把字符从最高位存起,即从arr[7]开始存起
num = num >>>4 ;
}
System.out.println("pos="+pos); //显示arr存到了哪个位置
//存储数据的arr数组遍历
for(int x = pos ; x<arr.length;x++) //输出字符数组,即十六进制结果
{
System.out.print(arr[x]+",");
}
public static void main(String [] args)
{
toHex(60); //调用函数
}
}
输出结果:3,C,
/*查表法:改进后十进制转换成二进制*/
class demo21
{
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.print(arr[x]);
}
}
public static void main(String [] args)
{
toBin(-6);
}
}
输出结果:11111111111111111111111111111010
进制转化优化
通过十进制转化为(二、八、十六)进制的例子我们可以发现他们之间存在许多重复的代码,我们可以把这些代码进行优化成一个通用的功能函数去转化。
代码:
class demo21
{ /*
转换函数,num是指输入的十进制整数,base是整数要与的位数,例如二进制要与1,八进制要与7,十六进
制要与15,而offset是指整数要右移的位数,例如二进制每次要右移1位,八进制每次要右移3位u,十六进制每次要右移4位
所以
要求二进制就调用trans(num,1,1);
要求八进制就调用trans(num,7,3);
要求十六进制就调用trans(num,15,4);
*/
public static void trans(int num,int base,int offset)
{
if(num == 0)
{
System.out.println(0); //当输入的数为0是直接输出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]);
}
}
public static void main(String [] args)
{
trans(60,1,1); //60的二进制
trans(60,7,3); //60的八进制
trans(60,15,4); //60的十六进制
}
}
输出结果:
111100
74
3C
8、数组(二维数组)
即数组中的数组。 初始化格式:(代码示例)
int [] arr = new int [3]; //一维数组定义
int [][] arr_2 = new int [3][4]; //二维数组定义:定义了名称为arr_2的二维数组,二维数组中有3个一维数组,每一个数组中有四个元素
如图:
另外一种初始化方法(专业方法):
int [][] arr = new int [3][];
//若System.out.print(arr[0]);
//输出结果是:null
如图:
如果输入以下代码:
arr[0] = new int [3];
arr[1] = new int [1];
arr[2] = new int [3];
System.out.println(arr.length); //打印的是二维数组的长度:3
System.out.println(arr[0].length);//3
System.out.println(arr[1].length);//1
System.out.println(arr[2].length);//2
如图: