------- android培训、java培训、期待与您交流！ ----------
第四天：
For循环嵌套：
class ForForDemo
{
public static voidmain(String[] args)
{
//大圈套小圈思想。
/*
for(intx=0; x<3; x++)
{
for(inty=0; y<4; y++)
{
System.out.println("ok");
}
}
*/
/*
*****
*****
*****
*****
*/
for(int x=0;x<4; x++)//外循环控制的是行数
{
for(inty=0; y<5; y++)//内循环控制的是每一行的个数
{
System.out.print("*");
}
System.out.println();
}
}
}
class ForFor99
{
public static voidmain(String[] args)
{
/*
九九乘法表
1*1=1
1*2=22*2=4
1*3=32*3=6 3*3=9
*/
for (int x=1;x<=9 ;x++ )
{
for (inty=1; y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
/*
\n:回车：
\t:制表符。
\b:退格。
\r:按下回车键。
windows系统中回车符其实是由两个符号组成的 \r\n.
linux中回车符是 \n.
System.out.println("\\helloworld\\");
*/
}
}
class ForForTest
{
public static voidmain(String[] args)
{
/*
*****
****
***
**
*
*/
/*
intz = 5;
for(int x = 1; x<=5 ;x++ )//1-5 1-4 1-3//1-5 2-5 3-5
{
for(int y=1; y<=z ; y++ )
{
System.out.print("*");
}
System.out.println();
z--;
}
*/
/*
intz = 1;
for(int x = 1; x<=5 ;x++ )//1-5 1-4 1-3//1-5 2-5 3-5
{
for(int y=z; y<=5 ; y++ )
{
System.out.print("$");
}
System.out.println();
z++;
}
*/
for(int x=1;x<=5; x++)
{
for(inty=x; y<=5; y++)
{
System.out.print("*");
}
System.out.println();
}
/*
*
**
***
****
*****
*/
System.out.println("----------");
for (int x=1;x<=5 ;x++ )
{
for (inty=1;y<=x ;y++ )
{
System.out.print("*");
}
System.out.println();
}
System.out.println("----------");
/*
54321
5432
543
54
5
*/
for (int x=1;x<=5; x++ )
{
for (inty=5; y>=x ;y-- )
{
System.out.print(y);
}
System.out.println();
}
System.out.println("----------");
/*
1
22
333
4444
55555
*/
for (int x=1;x<=5 ; x++)
{
for (inty=1;y<=x ;y++ )
{
System.out.print(x);
}
System.out.println();
}
}
}
Break和Continue语句
class BreakContinueDemo
{
public static voidmain(String[] args)
{
/*
break:跳出。
break作用的范围：要么是switch语句，要么是循环语句。
记住：当break语句单独存在时，下面不要定义其他语句，因为执行不到。
break跳出所在的当前循环。
如果出现了循环嵌套，break想要跳出指定的循环，可以通过标号来完成。
for(int x=0; x<3; x++)
{
if(x==1)
break;
System.out.println("x="+x);
}
xiaoqiang:for(int x=0; x<3 ;x++ )
{
wangcai:for(int y=0; y<4 ; y++)
{
System.out.println("x="+x);
breakxiaoqiang;
}
}*/
/*
continue:继续。
作用的范围：循环结构。
continue：结束本次循环，继续下次循环。
如果continue单独存在时，下面不要有任何语句，因为执行不到。
for(int x=0; x<11 ;x++ )
{
if(x%2==0)
continue;
System.out.println("x="+x);
}
*/
xiaoqiang:for(int x=0; x<3 ;x++ )
{
wangcai:for(int y=0; y<4 ; y++)
{
System.out.println("x="+x);
continuexiaoqiang;
}
}
}
}
函数：
函数的特点：
·定义函数可以将功能代码进行封装
·便于对该功能进行复用
·函数只有被调用才会执行
·函数的出现提高了代码的服用性
·对于函数没有具体返回值的情况，返回类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
·注意：
函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
class FunctionDemo
{
public static voidmain(String[] args)
{
// inta = 3;
// intb = 4;
// intc;
// c= a+b;
//
// c= 5+7;
// c= 9+8;
// intc = add(3);
// System.out.println("c="+c);
// System.out.println("helloworld");
// myPrint();
// myPrint();
}
/*
定义函数的格式：
修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，...)
{
执行语句;
return返回值;
}
特殊情况：
功能没有具体的返回值。
这时return的后面直接用分号结束。
返回值类型怎么体现呢？因为没有具体值，所以不可以写具体的数据类型。
在java中只能用一个关键字来表示这种情况。关键字是：void.
总结：没有具体返回值时，返回值类型用void来表示。
注意：如果返回值类型是void，那么函数中的return语句可以省略不写。
*/
public static voidmyPrint()
{
System.out.println("hellojava");
return ;
}
public static intadd(int a,int b)
{
return a+b;
}
}
class FunctionDemo2
{
public static voidmain2(String[] args)
{
// myPrint();
int x =add(3,5);//绞肉机
System.out.println("x="+x);
// System.out.println(add(3,5));
}
/*
publicstatic void add(int a,int b)
{
System.out.println(a+b);
return;
}
*/
public static intadd(int a,int b)
{
return a+b;
}
/**/
public static voidmyPrint()
{
System.out.println("HelloWorld!");
}
}
class FunctionDemo3
{
public static voidmain(String[] args)
{
// draw(4,6);
// draw(7,9);
// print99();
System.out.println("hello");
}
/*
需求1：定义一个功能，完成两个整数的和的获取。
思路：既然定义功能，就是可以用函数来体现。
如何定义一个函数呢？
通过两个明确来完成。
明确一：这个功能的结果是什么？
是和。是功能的结果，所以该功能的返回值类型是int 。
其实就是在明确函数的返回值类型。
明确二：这个功能实现过程中是否需要未知内容参与运算？
有，加数和被加数。这就是函数的参数列表(参数的个数，参数的类型)
其实就是在明确参数列表。
注意：返回值类型和参数类型没有直接关系。
*/
public static intadd(int a,int b)
{
int sum = a+b;
return sum;
}
/*
需求2：定义一个功能，画一个矩形在控制台。
明确一：这个功能的结果是什么？
没有结果，因为直接打印到了，控制台，并未返回给调用者。
用void表示。
明确二：这个功能实现过程中是否需要未知内容参与运算？
有，行和列不确定。两个。整数 int.
*/
public static voiddraw(int row,int col)
{
for (int x=1;x<=row ;x++ )
{
for (inty=1;y<=col ; y++ )
{
System.out.print("*");
}
System.out.println();
}
// return;//可以省略不写。
}
/*
需求3：定义一个功能，比较两个数是否相等。
明确一：这个功能的结果是什么？
有，boolean.
明确二：这个功能实现过程中是否需要未知内容参与运算？
有，两个整数。
*/
public static booleanequals(int a,int b)
{
/*
if(a==b)
returntrue;
else
returnfalse;
booleanx ;
if(a==b)
x= true;
else
x= false;
returnx;
*/
// return(a==b)?true:false;
return a==b;
}
/*
需求1：定义一个功能，获取两个整数中较大的那个数。
明确一：这个功能的结果是什么？
有，其中一个数。 int
明确二：这个功能实现过程中是否需要未知内容参与运算？
有，参与比较的两个整数 int
*/
public static intgetMax(int a,int b)
{
/*
if(a>b)
returna;
else
returnb;
*/
returna>b?a:b;
}
/*
定义功能，打印99乘法表。
*/
public static void print99()
{
for(int x=1;x<=9; x++)
{
for(inty=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
/*
根据考试成绩获取学生分数对应的等级
90~100 A
80~89 B
70~79 C
60~69 D
60以下 E
结果：等级，字符，char
参数：分数，int.
*/
public static chargetLevel(int num)
{
char level ;
if(num>=90&& num<=100)
level ='A';
elseif(num>=80 && num<=89)
level= 'B';
elseif(num>=70 && num<=79)
level= 'C';
elseif(num>=60 && num<=69)
level= 'D';
else
level = 'E';
return level;
}
}
函数的重载：
重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的特点：与返回值类型无关，只看参数列表。
重载的好处：方便阅读，优化程序设计
/*
需求：函数的重载。
*/
class FunctionDemo4
{
public static voidmain(String[] args)
{
// add(4,6,9);
// System.out.println("HelloWorld!");
printCFB(7);
}
/*
函数的重载。
1，同一个类，
2，同名。
3，参数个数不同。or 参数类型不同。
4，函数重载和返回值类型无关。
5，java是严谨性语言，如果函数出现的调用的不确定性，会编译失败。
*/
//加法运算。两个整数的和。
public static intadd(int a,int b)
{
return a+b;
}
//加法运算。两个小数的和。
public static doubleadd(double a,double b)
{
return a+b;
}
//加法运算，三个整数的和。
public static intadd(int a,int b,int c)
{
returnadd(a,b)+c;
}
/*
打印乘法表。
*/
public static voidprintCFB(int num)
{
for(int x=1;x<=num; x++)
{
for(inty=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
/*
打印标准乘法表。
*/
public static voidprintCFB()
{
printCFB(9);
}
}
数组：
概念：同一种类型数据的集合。其实数组就是一个容器。
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名=new 元素类型[元素个数或数组长度];int [] arr =newint[5]
格式二：
元素类型[] 数组名=new 元素类型[] {元素1，元素2...}
int [] arr=new int[]{1,2,3} ; int [] arr={1,2,3}
第一种定义格式：
class ArrayDemo
{
public static voidmain(String[] args)
{
//元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
{//局部代码块。限定局部变量的生命周期。
int age =3;
System.out.println(age);
}
int[] arr = newint[3];
// arr[0]= 89;
System.out.println(arr[0]);
for(int x=0;x<4; x++){}
}
}
/*
内存的划分：
1，寄存器。
2，本地方法区。
3，方法区。
4，栈内存。
存储的都是局部变量。
而且变量所属的作用域一旦结束，该变量就自动释放。
5，堆内存。
存储是数组和对象(其实数组就是对象) 凡是new建立在堆中。
特点：
1，每一个实体都有首地址值。
2，堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同。整数是0，小数0.0或者0.0f，booleanfalse char '\u0000'
3，垃圾回收机制。
*/
class ArrayDemo2
{
public static void main(String[] args)
{
int[] arr = newint[3];
// System.out.println(arr[3]);//ArrayIndexOutOfBoundsException:
//当访问到数组中不存在的角标时，就会发生该异常。
// arr= null;
// System.out.println(arr[0]);//NullPointerException
// 当引用型变量没有任何实体指向时，还在用其操作实体。就会发生该异常。
// System.out.println(arr);// [I@c17164
}
}
第五天：
第二中定义格式：
classArrayDemo3
{
public static voidmain(String[] args)
{
//格式1
/*
需要一个容器，但是不明确容器的具体数据。
*/
// int[]arr = new int[3];
/*
需要一个容器，存储已知的具体数据。
*/
//元素类型[] 数组名= new 元素类型[]{元素，元素，……};
// int[]arr = new int[]{89,34,270,17};
int[] arr ={89,34,270,17};
/*
对数组操作最基本的动作就是存和取。
核心思想：就是对角标的操作。
*/
System.out.println("length:"+arr.length);
for(int x=0;x<arr.length ; x++)
{
System.out.println("arr["+x+"]= "+arr[x]+";");//arr[0] = 89;
}
for(intx=arr.length-1; x>=0; x--)
{
System.out.println("arr["+x+"]= "+arr[x]+";");//arr[0] = 89;
}
// System.out.println(arr[1]);
// System.out.println(arr[2]);
// System.out.println(arr[3]);
}
}
对数组的操作：
import java.util.*;
class ArrayDemo4
{
//遍历数组的功能。
public static voidprintArray(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]+"]");
}
}
public static voidmain(String[] args)
{
int[] arr ={34,19,11,109,3,56};
// intmax = getMax_2(arr);
// System.out.println("max="+max);
printArray(arr);
// selectSort(arr);
// bubbleSort(arr);
// Arrays.sort(arr);
selectSort_2(arr);
printArray(arr);
}
public static voidswap(int[] arr,int a,int b)
{
int temp =arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/*
冒泡排序。
*/
public static voidbubbleSort(int[] arr)
{
for(int x=0;x<arr.length-1; x++)
{
for(inty=0; y<arr.length-1-x; y++)
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
/*
inttemp = arr[y];
arr[y]= arr[y+1];
arr[y+1]= temp;
*/
}
}
}
}
/*
选择排序。
*/
public static voidselectSort(int[] arr)
{
for(int x=0;x<arr.length-1; x++)
{
for(inty=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
/*
inttemp = arr[x];
arr[x]= arr[y];
arr[y]= temp;
*/
}
}
}
}
public static voidselectSort_2(int[] arr)
{
for(int x=0;x<arr.length-1; x++)
{
int num =arr[x];
int index= x;
for(inty=x+1; y<arr.length; y++)
{
if(num>arr[y])
{
num= arr[y];
index= y;
}
}
if(index!=x)
swap(arr,x,index);
}
}
/*
获取数组中的最大值。
思路：
1，需要进行比较。并定义变量记录住每次比较后较大的值。
2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
如果遍历到的元素大于变量中记录的元素，就用变量记录住该大的值。
3，遍历结果，该变量记录就是最大值。
定义一个功能来是实现。
明确一，结果。
是数组中的元素。int .
明确二，未知内容。
数组.
*/
public static intgetMax(int[] arr)
{
//定义变量记录较大的值。
int maxElement =arr[0];//初始化为数组中的任意一个元素。
for(int x=1;x<arr.length; x++)
{
if(arr[x]>maxElement)
maxElement= arr[x];
}
returnmaxElement;
}
public static intgetMax_2(int[] arr)
{
//定义变量记录较大的值。
int maxIndex = 0;//初始化为数组中任意一个角标。
for(int x=1;x<arr.length; x++)
{
if(arr[x]>arr[maxIndex])
maxIndex= x;
}
returnarr[maxIndex];
}
}
import java.util.*;
/*
面试题：
给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，
那么个元素的存储的角标为如何获取。
{13,15,19,28,33,45,78,106};
*/
class ArrayDemo5
{
public static voidmain(String[] args)
{
//
// int[]arr = {4,1,8,7,3,8,2};
int[] arr = {13,15,19,28,33,45,78,106};
int index =halfSearch_2(arr,5);
System.out.println("index="+index);
int index1 =Arrays.binarySearch(arr,5);//如果存在返回的具体的角标位置，不存在返回的是 -插入点-1
System.out.println("index1="+index1);
}
/*
二分查找法。
*/
public static inthalfSearch(int[] arr,int key)
{
int max,min,mid;
min = 0;
max =arr.length-1;
mid =(max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min= mid + 1;
elseif(key<arr[mid])
max= mid - 1;
if(max<min)
return-1;
mid =(max+min)/2;
}
return mid;
}
public static inthalfSearch_2(int[] arr,int key)
{
int max,min,mid;
min = 0;
max =arr.length-1;
while(min<=max)
{
mid =(max+min)>>1;
if(key>arr[mid])
min= mid + 1;
elseif(key<arr[mid])
max= mid - 1;
else
returnmid;
}
return -min-1;
}
/*
数组常见功能：查找。
*/
public static intgetIndex(int[] arr,int key)
{
for(int x=0;x<arr.length; x++)
{
if(arr[x]==key)
returnx;
}
return -1;
}
}
class ArrayTest
{
/*
给定一个数组，对其进行反转。
{3,1,6,5,8,2} -->
{2,8,5,6,1,3};
其实就是头尾元素的位置置换。
*/
public static voidprintArray(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]+"]");
}
}
public static voidmain(String[] args)
{
int[] arr ={4,1,8,7,3,8,2};
printArray(arr);
reverseArray(arr);
printArray(arr);
}
public static voidreverseArray(int[] arr)
{
for(int start=0,end=arr.length-1;start<end; start++,end--)
{
swap(arr,start,end);
}
}
public static voidswap(int[] arr,int a,int b)
{
int temp =arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
进制的转换（重要）：
class ArrayTest2
{
/*
获取一个整数的16进制表现形式。
*/
public static voidmain(String[] args)
{
toHex_2(0);
}
// 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,10,11,12,13,14,15
/*
什么时候使用数组呢？
如果数据出现了对应关系，而且对应关系的一方是有序的数字编号。并作为角标使用。
这时就必须要想到数组的使用。
就可以将这些数据存储到数组中。
根据运算的结果作为角标直接去查数组中对应的元素即可。
这种方式：称为查表法。
*/
public static voidtoHex_2(int num)
{
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 = newchar[8];
int pos =arr.length;
while(num!=0)
{
int temp =num&15;
arr[--pos]= chs[temp];
num = num >>> 4;
}
System.out.println("pos="+pos);
for(int x=pos ;x<arr.length;x++)
{
System.out.print(arr[x]);
}
}
public static voidtoHex_1(int num)
{
//定义一个对应关系表。
char[] chs ={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
for(int x=0 ;x<8; x++)
{
int temp =num & 15;
System.out.print(chs[temp]);
num = num>>> 4;
}
}
public static voidtoHex(int num)
{
for(int x=0;x<8; x++)
{
int temp =num & 15;
if(temp>9)
System.out.print((char)(temp-10+'A'));
else
System.out.print(temp);
num = num>>> 4;
}
/*
intn1 = num & 15;
System.out.println("n1="+n1);
num= num >>> 4;
intn2 = num & 15;
System.out.println("n2="+n2);
*/
}
}
class ArrayTest3
{
public static voidmain(String[] args)
{
// toHex(26);
toBinary(-6);
// toOctal(26);
System.out.println(Integer.toBinaryString(-6));
}
//十进制-->十六进制。
public static voidtoHex(int num)
{
trans(num,15,4);
}
//十进制-->二进制。
public static voidtoBinary(int num)
{
trans(num,1,1);
}
//十进制-->八进制。
public static voidtoOctal(int num)
{
trans(num,7,3);
}
public static voidtrans(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 = newchar[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]);
}
System.out.println();
}
}
class ArrayTest4
{
public static voidmain(String[] args)
{
String week =getWeek(71);
System.out.println(week);
}
/*
使用查表法。
星期。
Strings = "abc";
intx = 4;
*/
public static StringgetWeek(int num)
{
if(num>7 ||num<1)
{
return"错误的星期";
}
String[] weeks ={"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
returnweeks[num];
}
}
第六天：
二维数组：
格式1：int[][] arr = new int[3][2]
·定义了名称为arr的二维数组
·二维数组中有3个一维数组
·每个一维数组中有2个元素
·一维数组名称分别为arr[0],arr[1],arr[2]
·给第一个一维数组1角标位赋值78的写法是：arr[0][1]=78
格式二：int [][] arr=new int[3][]
·二维数组中有三个一维数组
·每个一维数组都是默认初始值null
·可以对这三个一维数组分别初始化
Arr[0]=new int[3]
Arr[1]=new int[2]
Arr[3]=new int[5]
/*
二维数组定义的格式。
*/
class Array2Demo
{
public static voidmain(String[] args)
{
// int[]arr = new int[3];
// System.out.println(arr);//[I@1fb8ee3 @左边是实体的类型。 @右边是实体的哈希值。
// int[][]arr = new int[3][2];//创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素。
// System.out.println(arr);//直接打印二维数组。 [[I@c17164
// System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。 [I@1fb8ee3
// System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 0
// int[][]arr = new int[3][];
// System.out.println(arr);//直接打印二维数组。 [[I@c17164
// System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。null
// System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。NullPointerException
// int[][]arr = new int[3][2];
// System.out.println(arr.length);//打印二维数组的长度。其实就是一维数组的个数。
// System.out.println(arr[1].length);//打印二维数组中角标为1一维数组的长度。
int sum = 0;
int[][] arr ={{3,1,7},{5,8,2,9},{4,1}};
for(int x=0;x<arr.length; x++)
{
for(inty=0; y<arr[x].length; y++)
{
// System.out.print(arr[x][y]+",");
sum+= arr[x][y];
}
}
System.out.println("sum="+sum);
// 甲：3059 28 17
// 乙；3760 22 19
// int[]arr = {{30,59,28,17},{37,60,22,19}};
int[][][] arr =new int[3][2][4];
}
}
/*
int[] x,y[];
int[] x;
int[] y[];
a
x = y;
b
x = y[0];
c
x[0] = y[0];
d
x[0] = y[0][0];
e
x[0] = y;
*/
扫一扫
881
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
