0
点赞
收藏
分享

微信扫一扫

实训Day2

elvinyang 2022-05-05 阅读 46
java

文章目录

前言

提示：以下是本篇文章正文内容，下面案例可供参考

一、循环嵌套

九九乘法表
/*
1X1=1
1X2=2 2X2=4
1X3=2 2X3=4 3X3=9
*/

for(int i=1;i<=9;i++){
	for(int j=1;j<=i;j++){
		System.out.print(j+"X"+i+"="+i*j+"    ");
	}
	System.out.println();
}

二、死循环

种类
for(; ; )
while(true)
do{ }while(true)
代码如下（示例）：

含义:循环条件一直都是成立的

for(;true;){
			System.out.println(new Date());
		}

while(true){
		System.out.println(new Date().getYear());
	}

do {
			System.out.println(new Date().getMonth());
		} while (true);

三、循环控制

//循环中断
//循环条件控制 break continue

	//break
	    //结束当前整个循环语句
	//continue
	    //跳过当次循环：

for(int i=1;i<=10;i++){
			if(i%2==0){
				break;
			}
			System.out.println(i);
		}

for(int i=1;i<=10;i++){
			if(i%2==0){
				continue;
			}
			System.out.println(i);
		}

四、循环控制

1、 //当i == 10的时候要跳过 并且 当i==20结束 【不能使用break】

int i = 1;
boolean sign = true;
for (; sign; ) {
    i++;
    if (i == 10) {
        continue;
    }

    if (i == 20) {
        sign = false;
    }
    System.out.println(i);
}

2.跳出双重循环

 System.out.println("方式一:");
        outSide : for (int a =1 ;a<=9 ;a++){
            for (int b = 1;b<=a;b++){
                System.out.println(b+"x"+a+"="+a*b);

                if (b==4 && a==7){
                    break outSide;// 此处的含义:中断当前所在的循环体并且中断outSide对应的循环体
                }
            }
            System.out.println();
        }

//这种方式连同上一题一定要在判断语句中带个boolean的变量
System.out.println("方式二:");
boolean flag = true;
for (int m = 1;m<=9 && flag;m++){
    for (int n =1 ;n<=m;n++){
        System.out.println(n+"x"+m+"="+m*n);

        if (n==4 && m==7){
            flag = false;
            break;
        }
    }
    System.out.println();
}

五、数组

1.一维数组

在这里插入图片描述
在这里插入图片描述
定义方式
数据类型 [] 数组名;
数据类型 [] 数组名=new 数据类型[size];
数据类型 [] 数组名={元素1,元素2,…,元素N}
数据类型 [] 数组名=new 数据类型[]{元素1,元素2,…,元素N}

//只是声明数组
		int [] age;
		//System.out.println(age);  //TODO 为什么报错 ??
		
		//没有初始化 初始化如下：
		
		//int [] age = new int[0];
        //System.out.println(age);
		
		int [] num = new int[4];             //num存储的是 new int[4]对象的地址
		             //[0,0,0,0]
		boolean [] sign = new boolean[4];    //sign存储的是new boolean[4]对象的地址
		                  //[false,false,false,false]
		
		
		String [] names = {"zs","ls","ww"};
		
		
		int id [] = new int [] {1,2,3,4,5};

//常用的操作
		int [] score;
		score = new int[]{80,90,100};
		
		//获取长度
		System.out.println(score.length);  //.xxx 属性  .xxx() 方法
		 
		//获取 0-2
		System.out.println(score[score.length-1]);
		
		//全部打印出来
		System.out.println("----遍历----");
		for(int i=0;i<score.length;i++){ //0 1 2 
			System.out.println("score["+i+"]="+score[i]);
		}
		
		//修改元素
		System.out.println("--------修改元素-------");
		score[0]=85;
		
		System.out.println(score[0]);
		
		
		//修改数组名的指向
		score = new int[]{70,80,90,100};


		//修改数组名的指向
		score = new int[]{70,80,90,100};
		 


		//常见的错误
		//System.out.println(score[4]);
		//ArrayIndexOutOfBoundsException //经验不足
		//NullPointerException           //经验不足
		    //调用了空对象的属性或者方法都会出现该异常
		String [] address=null;  //null 空对象
		//System.out.println(address.length);

2.多维数组

数据类型 [][] 数组名;
数据类型 [][] 数组名={{1,1},{2,2},{3,3}};
数据类型 [][] 数组名=new 数据类型 [][] {{1,1},{2,2},{3,3}};
数据类型 [][] 数组名=new 数据类型 [size1][size2]; //size2可以不写也可以写

在这里插入图片描述

 int [][] num;    //只是声明,没有初始化

int [][] data = {{1,2},{3,4},{4,5}};   //只能用于声明的时候

        for (int i = 0; i<3;i++) {
            System.out.println(Arrays.toString(data[i]));
        }
        System.out.println(data.length);//1

[1, 2]
[3, 4]
[4, 5]
3

int [][] index = new int[][]  {{1,2},{3,4},{4,5}};
        System.out.println(Arrays.toString(index[0]));
        System.out.println(Arrays.toString(index[1]));
        System.out.println(Arrays.toString(index[2]));

[1, 2]
[3, 4]
[4, 5]

 int [][] score = new int[4][3];
        for (int i = 0;i<4;i++)
            System.out.println(Arrays.toString(score[i]));
        System.out.println(score[0].length);

[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
3

  int [][] salary = new int[4][];
        for (int i = 0 ;i<4;i++)
        System.out.println(Arrays.toString(salary[i]));

null
null
null
null

int [] temp = score[0];
for (int i =0 ;i<temp.length;i++)
    System.out.println(temp[i]);

System.out.println(salary[0]);

0
0
0
null

System.out.println("----------------修改-------------------");
score[2][2] = 5;
salary[1] =  new int[] {1,2,3};

System.out.println(score[2][2]);//5

for (int i =1 ; i<=2 ;i++)
    System.out.println(score[i][i]);

System.out.println(Arrays.toString(salary[1]));

----------------修改-------------------
5
0
5
[1, 2, 3]

  System.out.println("----------------遍历-------------------");
        for(int i=0;i<score.length;i++){
            System.out.print("[");
            for(int j=0;j<score[i].length;j++){
                if(j==score[i].length-1){
                    System.out.print(score[i][j]);
                }else{
                    System.out.print(score[i][j]+",");
                }
            }
            System.out.println("]");
        }

----------------遍历-------------------
[0,0,0]
[0,0,0]
[0,0,5]
[0,0,0]

        System.out.println("----------------案例-------------------");
        int [][] score1 = new int[4][6];
        for (int i =0 ;i< score1.length;i++)
        System.out.println(Arrays.toString(score1[i]));

        Random random = new Random();//0-100

        for (int row = 0;row < score1.length;row++){
            for (int col = 0;col < score1[row].length;col++){
//                score1[col][row] = random.nextInt();
            }
        }

        for (int row = 0 ;row < score1.length;row ++){
            System.out.println(Arrays.toString(score[row]));
        }

[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0]
[0, 0, 0]
[0, 0, 5]
[0, 0, 0]

System.out.println("----------------查找最大值-------------------");
        int max = 0;
        for (int row = 0;row < score1.length;row++){
            for (int col = 0;col < score1[row].length;col++){
                      if (score1[row][col] > max){
                          max = score1[row][col];
                      }
            }
        }
        System.out.println(max);

----------------查找最大值-------------------
0

六、排序

//斐波那契数列
    // 0 1 1 2 3
    public static  int fibo(int position){
        if(position < 1){
            return  -1;
        }
        else if (position ==    1) {
            return 1;
        }
        else if (position == 2){
            return 1;
        }
        return fibo(position-1)+fibo(position-2);
    }

55

 //冒泡排序
        //9 8 7 6
        //第一轮9 8 7 6
               //第一次 8 9 7 6
               //第二次 8 7 9 6
               //第三次 8 7 6 9
        //第二轮8 7 6 9
               //第一次 7 8 6 9
               //第二次 7 6 8 9
        //第三轮7 6 8 9
               //第一次 6 7 8 9
    public static int[] BubbleSort(){
        //注意j从0开始
        int [] data = {9,8,7,6};

        int time = data.length-1;

        for(int i=1;i<=time;i++){
            for(int j=0;j<=time-i;j++){
                System.out.println("第"+i+"轮第"+(j)+"次");
                if(data[j]>data[j+1]){
                    int temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                }
            }
        }
         return data;
    }
}


第1轮第0次
第1轮第1次
第1轮第2次
第2轮第0次
第2轮第1次
第3轮第0次
[6, 7, 8, 9]

 //选择排序
    //9 8 7 6
      //第一轮9 8 7 6
             //第一次 8 9 7 6
             //第二次 7 9 8 6
             //第三次 6 9 8 7
      //第二轮6 9 8 7
             //第一次 6 8 9 7
             //第二次 6 7 9 8
      //第三轮6 7 9 8
             //第一次6 7 8 9
    public static int[] SelectSort(){
        int [] data1 = {9,8,7,6};

        int time = data1.length-1; //3

        for(int i=1;i<=time;i++){
            for(int j=i;j<=time;j++){

                //i=1 j 1 2 3
                //i=2 j 2 3
                //i=3 j 3
                System.out.println("第"+i+"轮第"+j+"次");

                if(data1[i-1] > data1[j] ){
                    int temp = data1[i-1];
                    data1[i-1] = data1[j];
                    data1[j]=temp;
                }
            }
        }
        return data1;
    }

第1轮第1次
第1轮第2次
第1轮第3次
第2轮第2次
第2轮第3次
第3轮第3次
[6, 7, 8, 9]

//查找
//顺序查找
//缺点:如果数据多且要查找的数据在最后面，比较次数太多性能差
//二分查找【也称:折半查找】
//缺点
//需要对数据进行先排序
//优点:撇开排序性能外,查找效率高【因为折半】
public static int BinarySearch(){
    int [] data = {1,2,3,4,5,6};

    int target = 100;
    int result = -1;

    int start = 0;
    int end = data.length-1;

    while(start<=end){
        int middle = (start+end)/2;
        if(data[middle]==target){
            result = middle;
            break;
        }else if(data[middle] < target){
            start = middle+1;
        }else{
            end = middle-1;
        }
    }
    return result;
}

七、可变参数

含义
放在方法的最后一个参数,它的本质就是一个数组

语法
方法名(参数1,…,参数N,类型 … 参数名);

注意点
只能是方法的最后一个参数
一个方法最多只能有一个可变参数

public static void main(String[] args) {
	say();   
	say("a");  
	say("a","b"); 
}

public static void say(String ... content){
	
	//content 本质就是数组
	//System.out.println(content.length);
	
	System.out.println(Arrays.toString(content));
	
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

八、Foreach

//forEach
    //含义:增强for
    //作用
         //遍历数组                 【本质还是通过下标获取】
         //遍历部分集合
    //遍历数组的语法
       //for(元素类型  名称  : 数组名){

       //}

public static void main(String[] args) {
	
	int [] age = {1,2,3,4};
	
	//方式一
	System.out.println("方式一");
	for(int i=0;i<age.length;i++){
		System.out.println(age[i]);
	}
	
	//方式二
	System.out.println("方式二");
	int length = age.length;
	for(int i=0;i<length;i++){
		System.out.println(age[i]);
	}
	
	//方式三 for each 
	System.out.println("方式三");
	for(int temp : age){
		System.out.println(temp);
	}
}

九、面向对象

1.概念

在这里插入图片描述
在这里插入图片描述

2.匿名对象

在这里插入图片描述

十、JVM内存模型

在这里插入图片描述
在这里插入图片描述

1. GC

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.finalize

当对象被回收的时候会先调用对象的finalize方法

System.gc()
手动通知GC执行一次回收操作

//回收场景
//没有被引用
//匿名对象
//超出范围

		//System.gc() 手动通知GC执行一次操作
		//finalize    当对象被回收的时候会先执行该对象的此方法
		
        //没有被引用
		/*
		User user = new User();
		user.name="lw";
		user = null;
		*/
		
        //匿名对象
		//new User().name="xiaohong";
		
        //超出范围
		for(int i=0;i<10;i++){
			new User().name="老王"+i;
		}
		
		//手动调用GC
		System.gc();
	}
}
class User{
	String name;
	
	@Override
	protected void finalize() throws Throwable {
		 System.out.println(name+"会回收了");
	}
}

3.变量

//变量
    //局部变量:
          //位置:方法里面的
          //作用范围:在方法中声明开始到方法结尾
          //是否初始值?没有初始值
    //成员变量
          //位置:和方法同级别
          //作用范围:在整个类中
          //是否有初始值:有
               //基本数据类型的初始值:
                   //整数:byte short int long  初始值0
                   //float:0.0f 
				   //double:0.0D
				   //boolean:false
				   //char: 0 对应字符

               //引用数据类型初始值都是null

    //注意点
       //如果局部变量和成员变量名字相同时,使用的时候遵循靠近原则

//相同作用范围变量名不能重复定义:

4.对象比较

== 比较两个对象的地址是否一样

equals 方法 以后学习

instanceof 判断对象是否属于某个类的实例

public class _09ObjectEqualExpress {
	
	public static void main(String[] args) {
		
		//比较运算符:  ==  instanceof
		     //==如果用在比较引用数据类型,比较内存地址
		
		Car one = new Car();
		one.name="比亚迪";
		
		Car two = new Car();
		two.name ="比亚迪";
		
		System.out.println(1==1);
		
		System.out.println(one == two); //false
		
		System.out.println(one instanceof Car);
		System.out.println(two instanceof Car);
	}
}

class Car{
	String name;
}

true
false
true
true
举报

相关推荐

网络安全实训Day2

网络智能路由器运维计算机网络

云监控（华为） | 实训学习day2（10）

apache

Day2

赋值字符串运算符软件测试

#day2

linux

day2——

排序算法算法数据结构

实训day29(8.15)

devops

qt day2

linux

Qt day2

mybatis缓存java

RHCE Day2

linux

Python day2

字符串双引号缓存Python编程语言
0 条评论