Java基础总结2
- 数组
格式1：
元素类型 [] 数组名 = new 元素类型 [元素个数或数组长度]
示例：int [] arr = new int [5]
格式2：
元素类型 [] 数组名 = new 元素类型 [] {元素、元素、元素………..}
示例：int [] arr = new int [5] {1,2,3,4,5}
格式3：元素类型 [] 数组名 = {元素、元素、元素………..}
示例：int [] arr = {1,2,3,4,5}
打印数组角标上的值、遍历数组、打印数组长度。
class shuzu
{
publicstatic void main(String[] args)
{
int[] arr = new int [] {1,2,3,4,5};
System.out.println("arr数组1角标上的值="+arr[1]);
int[] ar = new int [5];
System.out.println("ar数组1角标上的值="+ar[1]);
for(int x=0;x<=arr.length-1;x++ )
{
System.out.println("遍历数组"+arr[x]);
}
System.out.println("数组长度"+arr.length);
}
}
求int类型数组中的最大值
示例1：
class shuzu
{
publicstatic void main(String[] args)
{
int[] arr = new int [] {100,82,96,84,5};//定义一个数组
intmax = arr[0];//定义一个值用来和其他值比较。
for(int x=1;x<arr.length ;x++ )//使用for循环遍历数组
{
if(max<arr[x])
{
max=arr[x];//使用max变量记住最大值
}
}
System.out.println(max);
}
}
示例2;通过函数的方式定义一个获取任意int类型数组最大值
class shuzu
{
publicstatic void main(String[] args)
{
int[] arr = new int [] {100,82,96,84,5};
intmax = getmax(arr);//定义一个值，用来比较，并且调用下面的getmax函数，同时把数组arr传入到该函数。
System.out.println(max);
}
publicstatic int getmax (int [] arr )
{
intmax = arr[0];
for(int x=1;x<arr.length ;x++ )
{
if(max<arr[x])
{
max=arr[x];
}
}
returnmax;//返回一个最大值。
}
}
数组排序
示例1：选择排序
思路：
1、要将无序数组排序，首先需要将数组打印出来。
2、建立一个打印数组的方法。
3、建立一个排序的方法，首先要排序就要让数组中的元素进行比较，并且需要将小值放到前面，也就是调换位置，可以通过第三方变量的方式来实现元素的调换。
class shuzu
{
publicstatic void main(String[] args)
{
int[] arr = {1,2,4,6,3,5,7,10,9,8};
paixu(arr);//调用排序方法
printarr(arr);//调用打印数组方法
}
publicstatic void paixu (int [] arr)
{
for(int x=arr[0];x<arr.length ;x++ )
{
for(int y=x;y<arr.length ;y++ )
{
if(arr[x]>arr[y])
{
inttemp =arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
public static void printarr (int [] arr)
{
for(int x=0;x<arr.length ;x++ )
{
System.out.print(arr[x]+" ");
}
}
}
示例2：冒泡排序
class shuzu
{
publicstatic void main(String[] args)
{
int[] arr = {1,2,4,6,3,5,7,10,9,8};
paixu(arr);//调用排序方法
printarr(arr);//调用打印数组方法
}
publicstatic void paixu (int [] arr)
{
for(int x=0;x<arr.length-1 ;x++ )//-1表示最后一个值不用比较
{
for(int y=0;y<arr.length-x-1 ;y++ )//-x表示每次少比较1次
{
if(arr[y]>arr[y+1])
{
inttemp =arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
public static void printarr (int [] arr)
{
for(int x=0;x<arr.length ;x++ )
{
System.out.print(arr[x]+" ");
}
}
}
数组的查找
示例1：普通遍历查找
class chazhao
{
publicstatic void main(String[] args)
{
int[] arr = {2,3,4,1,8,6};
intc=cz (arr,6);//调用查询方法，并且把arr数组和需要查找的key传入到查找方法中。
System.out.println(c);
}
publicstatic int cz(int [] arr , int key)//定义一个查询方法。
{
for(int x=0;x<arr.length ;x++ )
{
if (arr[x]==key)//定义判断条件
{
returnx;//满足条件返回该值
}
}
return-1;//不满足条件返回-1
}
}
示例2：折半查找
折半查找只能查找有序的数组
示例1：使用while循环语句直接判断条件查找
class sz
{
publicstatic void main(String[] args)
{
int[] arr = {1,3,5,7,10,11,12,13,14,16};
inta=cz (arr,-10);//调用cz方法查询arr数组中-10的角标
System.out.println("a="+a);
}
publicstatic int cz (int [] arr,int key)
{ int min = 0;//定义一个最小值
intmax = arr.length-1;//定义一个最大值，最大值为数组长度-1
intmid = (min+max)/2;//定义中间值，中间值为最小值加最大值除以2
while(key!=arr[mid])//定义循环条件，如果key=中间值时则直接返回中间值。
{
if(key>arr[mid])//判断key是否大于中间值时
{
min=mid+1;//如果大于中间值，最小值等于中间值加1，游标向右移动
}
elseif (key<arr[mid])//判断key是否小于中间值
{
max=mid-1;//如果小于中间值，则最大值等于中间值减1，游标向左移动。
}
if(min>max)//防止游标越界
{
return-1;//表示超出范围
}
mid=(min+max)/2;//再次进行折半查找
}
returnmid;
}
}
示例2 ：
相对示例1简化了代码，并且减少了循环次数。
class sz
{
publicstatic void main(String[] args)
{
int[] arr = {1,3,5,7,10,11,12,13,14,16};
inta=cz (arr,10);//调用cz方法查询arr数组中-10的角标
System.out.println("a="+a);
}
publicstatic int cz (int [] arr,int key)
{
intmin = 0;//定义一个最小值
intmax = arr.length-1;//定义一个最大值，最大值为数组长度-1
intmid = (min+max)/2;//定义中间值，中间值为最小值加最大值除以2
while(min<=max)//首先判断是否越界，如果最小值大于最大值则直接返回-1
{
mid= (min+max)/2;//先将数组折半
if(key>arr[mid])//判断key值游标方向
{
min=mid+1;
}
elseif (key<arr[mid])//判断key值游标方向
{
max=mid-1;
}
else
returnarr[mid];//如果满足条件返回对应值。
}
return-1;//如果越界的话直接返回-1。
}
}
使用数组编写进制转换程序：
示例1：简单二进制转换
思路：
1、十进制转换到二进制是一个模以2，除以2的过程。
2、创建一个函数，实现任意十进制数转换2进制，需要定义一个num变量。
3、创建一个循环，用来实现不断模以2除以2的过程。并使用打印语句将模以2的结果打印出来。
publicstatic void te (int num)
{
StringBuffersb = new StringBuffer ();//定义一个容器，来存贮模以2的值，并实现反转
while(num>0)//定义循环条件，当前函数只能实现正数的二进制转换。
{
System.out.println(num%2);//打印的模以二的数值就是二进制数，但结果是倒的。
sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());//打印存进这个容器中的数值，并反转。
}
示例2十六进制转换
十进制==>>十六进制
取最低4位，算一个值，再取下一个四位，算一个值
60的二进制：0000-0000 0000-0000 0000-0000 0011-1100
0000-0000 0000-0000 0000-0000 0011-1100 ==>>60
&0000-0000 0000-0000 0000-0000 0000-1111 ==>>15
-----------------------------------------
0000-00000000-0000 0000-0000 0000-1100 ==>>12==>>C
0000-00000000-0000 0000-0000 0011-1100 >>>无符号右移
0000-0000 0000-0000 0000-0000 0000-0011右移后等于3
60的十六进制为3C
因为右移8次，所以循环需要8次
class jz
{
publicstatic void main(String[] args)
{
sl(16);
}
publicstatic void sl (int num)
{
StringBufferab = new StringBuffer ();//定义Stringbuffer容器来存储数据，
for(int x=0;x<8;x++ )//因为每次右移4位，需要移动8次。0000-0000 0000-0000 0000-0000 0000-0000
{
inttemp =num &15;
if(temp>9)
// System.out.print((char)(temp-10+‘A‘));
ab.append ((char)(temp-10+‘A‘));//将运行结果储存到容器中
else
// System.out.print(temp);
ab.append(temp);//将运行结果储存到容器中
num=num>>> 4;
}
System.out.println(ab.reverse());//将储存到容器中的结果反转打印出来。
}
}
示例3、查表法的16进制转换
class jz
{
publicstatic void main(String[] args)
{
sl3(60);
}
publicstatic void sl3 (int num)
{
//定义一个数组，存储16进制中多涉及的数字。
char[] chs={‘0‘,‘1‘,‘2‘,‘3‘,‘4‘,
‘5‘,‘6‘,‘7‘,‘8‘,‘9‘,
‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘F‘};
//定义一个8个元素的数组。
char[] a =new char[8];
intpost =0;
while(num!=0)
{
inttemp = num&15;
a[post++]= chs[temp];//先赋值给post再++
num= num >>>4;
}
for(int x=post-1;x>=0 ;x--)
{
System.out.print(a[x]);
}
}
/*
1、定义数组，数组包含16进制数中的所有元素
2、定义一个数组用来存储转换后的数值
3、定一个查找的指针，确定临时数据存储的位置。
4、使用for语句遍历存储后的数组，并打印。
*/
}
示例4、进制转换方法
实现十进制到二进制、八进制、十六进制的转换。
思想：
1、 进制转换是通过循环&一个数，并且通过右移来进行计算的。
2、 建立方法，首先先例一个进制转换的方法，并定义变量，包括num，要&的基数以及需要右移的位数。
class jz2
{
publicstatic void main(String[] args)
{
er(60);
sl(60);
ba(60);
}
publicstatic void er (int num)
{
sl3(num,1,1);
}
publicstatic void sl (int num)
{
sl3(num,15,4);
}
publicstatic void ba (int num)
{
sl3(num,7,2);
}
publicstatic void sl3 (int num , int base , int bit)
{
//定义一个数组，存储16进制中多涉及的数字。
char[] chs={‘0‘,‘1‘,‘2‘,‘3‘,‘4‘,
‘5‘,‘6‘,‘7‘,‘8‘,‘9‘,
‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘F‘};
char[] arr = new char [32];//存储数据
intpost =0;//定义指针，确定临时数组中的存储位置
if(num==0)
{
System.out.println(‘0‘);
}
while(num!=0)
{
inttemp = num&base;
arr[post++]= chs[temp];
num= num>>>bit;
}
for(int x=post-1;x>=0 ;x--)//post在上面的循环中已经是最大值，这里就必须使用--.从post的位置打印。
{
System.out.print(arr[x]);
}
System.out.println();
}
}
二维数组
二维数组本质上是以数组作为数组元素的数组，即“数组的数组”。
格式：
int [] []arr =new arr [4] [5]
int [] []arr =new arr{{1,2,3,4},{5,6,7,8,9}}
示例1、定义一个二维数组遍历并打印元素内容的方法。
思路：
1、 因为是二维数组的遍历，肯定要用到for嵌套循环，外循环确定小数组的个数，内循环确定小数组内的元素。
2、 就像打印矩形一样（也可以理解成表格），外循环是行数，内循环是列数。
class sz3
{
publicstatic void main(String[] args)
{
int[] [] arr ={{1,2,3,4},{5,6,7,8},{9,10,11,12,13},{14,15,16,17,18}};
bl(arr);
}
publicstatic void bl (int [] [] arr)
{
for(int x=0;x<arr.length ;x++ )//定义for循环，x应该是二维数组中的小数组个数。
{
System.out.print(x+"数组");
for(int y=0;y<arr[x].length ;y++ )//定义一个内循环，来遍历小数组中的元素，arr[x]指的是小数组的元素角标。
{
System.out.print(arr[x][y]+"");
}
System.out.println();
}
}
}
- 方法（函数）
概念：方法就是一段可以重复调用的代码段，在Java中如果某些代码希望可以被重复调用的时候，就可以使用方法进行定义，但是在定义的时候，因为现在要求所有的方法是可以由主方法直接调用的，所以，此时的方法声明格式如下：
public static 返回值类型 方法名称 (参数列表)
{
return 返回值；
}
在定义方法的时候方法名称的书写要求，第一个单词的首字母小写，之后的每个单词首字母大写
示例 1：
public class TestDemo
{
public static void main(String args [] )
{
testPrint(19);
}
public static voidtestPrint (int num)//定义了一个打印数据的方法。
{
System.out.println(num);
}
}
示例2、当方法指定了返回值类型，就必须使用return返回。（void表示没有具体返回值类型）
class tes1
{
publicstatic void main(String[] args)
{
intx = add(10,20);
System.out.println(x);
}
publicstatic int add (int x , int y)
{
inttemp =x+y;
returntemp;
}
}
使用void声明的时候也可以使用return返回值。
方法的重载：
方法名称相同，但参数列表不同。当返回值类型不同时，并不是函数的重载。
class tes1
{
publicstatic void main(String[] args)
{
intx = add(10,20);
inty = add (10,20,30);
System.out.println(y);
}
publicstatic int add (int x , int y)
{
inttemp =x+y;
returntemp;
}
publicstatic int add(int x, int y, int z)
{
inttemp = x+y+z;
returntemp;
}
}
方法的递归
指的是一个方法不段的调用自己。
示例：
class tes1
{
publicstatic void main(String[] args)
{
intnum=0;
for(int x=0;x<=100 ;x++ )
{
num+=x;
}
System.out.println(num);
}
}
关于方法的调用，可以参考上面数组中的代码。