java基础2

找个好工作(正在进行时)

已于 2024-07-17 22:29:36 修改

阅读量261

点赞数 4

文章标签： java 开发语言

于 2024-07-15 19:26:25 首次发布

本文链接：https://blog.csdn.net/qq_63095129/article/details/140436521

版权

运算符

1.位运算符二进制运算

1.1按位与运算“ & ” A&B
将A和B转成二进制右侧对其上下比较，两者都为1，结果才为1，否则为0，
1.2按位或运算 “ | ”
将A和B都转为二进制右侧对齐上下比较，两则有一个为1，结果就为1，两个都为0，结果才为0。1.3按位异或运算 “ ^ ”
将A和B都转为二进制，右侧对齐上下比较，两者不同则为1，相同则为0

  //运算符
        //位运算符 二进制运算
        int result=12&3;
        System.out.println(result);
        //按位与运算 &  A&B
        //将A和B转成二进制  右侧对其上下比较，两者都为1
        // 结果才为1，否则为0
        result=12 &11;
        System.out.println(result);//8

        //按位或运算    |
        result=12|11;
        //将A和B都转为二进制 右侧对齐上下比较，两则有一个为1，结果就为1
        //两个都为0，结果才为0         //1100
        System.out.println(result);//1011
                                   //1111=15
        //按位异或运算   ^
        result=12^11;
        //将A和B都转为二进制
        // 右侧对齐上下比较，两者不同则为1，相同则为0
        System.out.println(result);//7

2.1加法交换：

 a=11;
        b=22;
        a=a+b;//a=33 b=22
        b=a-b;//a=33 b=11
        a=a-b;//a=22 b=11
        System.out.println(a+"===="+b);

2.2异或运算

//异或运算
        a=11;
        b=22;
        a=a^b;//a=29 b=22
        b=a^b;//a=29 b=11
        a=a^b;//a=22 b=11

2.3反码运算

//反码运算
        result=~11;//1011  0100 1011+1  1100
        // 反码 ~ 将二进制中的0换成1，1换成0
        System.out.println(result);
        result=~-11;//
        System.out.println(result);

2.4移位运算

//移位运算   <<  向左移位 放大
        result=3<<2;
        System.out.println(result);

 //>>   左侧补符号位
        result=-1>>2;
        System.out.println(result);
        result=3>>1;
        System.out.println(result);

        //>>> 空出来的位置补0
        System.out.println(Integer.MAX_VALUE);
        result=-1>>>1;

        // &   |   也可以对boolean进行运算 得到boolean值
        boolean bool=true &false;//&和&&运算结果是一样的
        a=12;
        b=12;
        bool=a++<12&b++>12;

        //3*8最快计算方式  3<<3
        //3*16           3<<4
    }

赋值运算

1.1赋值运算 = 、+=、 -=、*=、/=、%=

 //赋值运算 = +=  -=  *=  /=  %=
        int a=12;
        a+=2;
        a=+2;

        a-=2;
        a=-2;
        a*=2;
        a/=2;
        a%=2;

1.2三元运算 A？B：C

//三元运算     A?B:C
        int result=12>34?11:23;
        System.out.println(result);
        result=12.2!=33.99?'a':33;

        //12.2+3   ? double
        System.out.println(true?3:4.0);//3.0
        System.out.println(12/0);

if……else和switch

switch :匹配某一个变量的值，如果匹配到某一个case项开始运行

break:运行到break或者代码块结束

1.case项和default的顺序写的时候可以打乱, 执行顺序不会受到影响

2.switch 可以匹配的类型：byte,short,int,char ,String,Enum（枚举）

3.所有的case项都没有匹配成功才会执行default

package com.easya;

import java.util.Scanner;

public class EasyC {
    public static void main(String[] args) {
        //流程控制
        Scanner scan=new Scanner(System.in);
//        System.out.print("输入成绩");
//        int score=scan.nextInt();
//          int score=80;
//        //if……else
//        if(score>=60){
//            System.out.println("及格");
//        }else{
//            System.out.println("不及格");
//        }

        int age=80;
        if(age>60 && age<70){
            System.out.println("500");
        }else if(age>=70){
            System.out.println("800");
        }


        System.out.println("--------------");
        //Switch case
        int num=2;
        //switch 匹配某一个变量的值，如果匹配到某一个case项开始运行
        //运行到break或者代码块结束

        //1.case项和default的顺序写的时候可以打乱,
        // 执行顺序不会受到影响
        //2.switch 可以匹配的类型：byte,short,int,char
        // ,String,Enum（枚举）
        switch(num){
            case 1:
                System.out.println("第1");
                break;//退出，结束代码块
            case 2:
                System.out.println("第2");
                break;
            case 3:
                System.out.println("第3");
                break;
            case 4:
                System.out.println("第4");
                break;
            default:
                System.out.println("不能解析");
                //所有的case项都没有陪陪成功才会执行default
        }
        System.out.println("==========");
        //1.成绩  60以下不及格  60-70及格
        //70-85良好 85以上优秀
        System.out.print("输入成绩");
        int score=scan.nextInt();
        if(score<60){
            System.out.println("不及格");
        }else if(score>=60 && score<70){
            System.out.println("及格");
        }else if(score>=70 && score<85){
            System.out.println("良好");
        }else if(score>=85){
            System.out.println("优秀");
        }

        //2.月份 123春季  456夏季 789秋季 10，11，12冬季
        System.out.print("输入月份");
        int month=scan.nextInt();
        if(month>0&&month<=3){
            System.out.println("春季");
        }else if(month>3&&month<=6){
            System.out.println("夏季");
        }else if (month>6&&month<=9){
            System.out.println("秋季");
        }else if (month>9&&month<=12){
            System.out.println("冬季");
        }

        scan.close();
    }
}

循环：for while break continue

1.while(继续循环的条件){ // 循环体 // }

while 先进行条件判断，再进行循环 (适合不知道循环次数的循环）

do...while 先循环再进行条件判断至少执行一次循环

2.for循环（适合知道循环次数的）

3.break 跳出多重循环

4.continue;//跳过本次循环，直接执行下一次循环语句

5.死循环没有结束条件的循环,之后不能写其他代码

6.无限循环结束循环的条件永远达不到，可以编写其他代码

package com.easya;

public class EasyD {
    public static void main(String[] args) {
        //循环  while  for

//        while(继续循环的条件){
//            循环体
//        }
        int i=0;
        while(i<5){
            System.out.println("A");
            i++;
        }

        //用循环打印abcd
        i='a';
        while(i<'a'+4){
            System.out.println((char)i);
            i++;
        }

        i='a';
        while(i<='d'){
            System.out.println((char) i);
            i++;
        }
        //while 先进行条件判断，再进行循环   (适合不知道循环次数的循环）
        //do...while  先循环再进行条件判断  至少执行一次循环
        i=1;
        do {
            System.out.println("-------条件不成立");
        }while (i>20);


        //for循环   （适合知道循环次数的）
        for(int n=0;n<10;n++){  //n<10继续循环的条件
            System.out.println(1+n);
        }

        Math.random();//能获取这个[0-1)区间的随机数
        int cat=100;
        int mouse=(int)(Math.random()*120);
        int count=0;
        while(cat>mouse){
            count++;
            mouse=(int)(Math.random()*120);
        }
        System.out.println("猫一共抓了"+count+"只老鼠");

        //1-100  累加
//        int a=1;
//        int sum=0;
//        while(a<=100){
//            sum=sum+a;
//            a++;
//        }
//        System.out.println(sum);

        //100以内三的倍数相加
        int sum=0;
       for(i=1;i<=100;i++){
           if(i%3==0){
               sum=sum+i;
           }
       }
        System.out.println(sum);

       //break  contiue
//
        for(int b=1;b<100;b++){
            if (b%7==0){
//                break;//结束所在的循环体
                continue;//跳过本次循环，直接执行下一次循环语句
            }
            System.out.println(b);
        }

        //break 跳出多重循环
        a:for (;;){ //冒号前面是一个标签名字
            for (;;){
                for (int c=0;c<100;c++){
                    if(c==50){
                        break a;//跳出循环a
                    }
                }
            }
        }

        //变量控制多重循环
//        boolean bool=true;
//        a:for (;bool&&...;){ //冒号前面是一个标签名字
//            for (;bool&&...;){
//                for (int c=0;bool&&c<100;c++){
//                    if(c==50){
//                        bool=false;//跳出循环
//                    }
//                }
//            }
//        }

        //死循环  没有结束条件的循环,之后不能写其他代码
        //无限循环  结束循环的条件永远达不到，可以编写其他代码

        /*
        int a=0;
        while(a<1000){//无限循环
        }

        for (;;){

        }

        while (true){}//死循环

         */
    }
}

数组

数组的定义

//定义
        int[] arr={1,2,3};//声明一个int 类型数组的变量
        int[] arrA=new int[4];//长度定义数组
        //[4]代表可以存放4个元素
        int[] arrB=new int[]{23,24};//静态

数组的限定

1.只能存放指定类型的数据

2.数组的长度是不可变的

下标：使用数组中的元素下标从0开始依次增加

package com.easya;

import java.util.Arrays;

public class EasyE {
    public static void main(String[] args) {
        //数组
        //定义
        int[] arr={1,2,3};//声明一个int 类型数组的变量
        int[] arrA=new int[4];//长度定义数组
        //[4]代表可以存放4个元素
        int[] arrB=new int[]{23,24};//静态

        //数组的限定
        //1.只能存放指定类型的数据
        //2.数组的长度是不可变的

        //使用数组中的元素 下标 从0开始依次增加
        System.out.println(arr[2]);
        System.out.println(arr);//第一个元素的地址
//        arr[0]=99;
        System.out.println(Arrays.toString(arr));//将数组转成字符打印出来

        System.out.println(arr.length);//获取数组的长度

        //打印出arr数组中所有的元素
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        //二维数组
        int[][] arrs=new int[4][2];
        arrs[0][1]=12;
        System.out.println(Arrays.deepToString(arrs));

        //二维数组的限定   一维数组的个数不可变
        arrs[2]=new int[]{1,2,3,4};
        System.out.println(Arrays.deepToString(arrs));

        //声明一个二维数组 使用随机数为每个元素赋值
        int[][] arrC=new int[5][4];
        for (int i=0;i<arrC.length;i++){
            System.out.println(Arrays.toString(arrC[i]));
            for(int j=0;j<arrC[i].length;j++){
                //对每个元素进行赋值
                arrC[i][j]=(int)(Math.random()*88);
            }
            System.out.println(Arrays.toString(arrC[i]));
        }
        System.out.println(Arrays.deepToString(arrC));

        //数组下标越界
        arr=new int[4];
        System.out.println(arr);
        arr[1]=34;
        arr[3]=99;
        arr[4]=8;
    }

}

相关题型及代码：

1.声明一个数组并赋值,打印出数组的最大值

package com.easya;

import java.util.Arrays;

public class ZuoA {
    public static void main(String[] args) {
        //声明一个数组并赋值,打印出数组的最大值
        int[] arr={4,3,6,7,9,12,2,1,0};
        int max=arr[0];
        for(int i=0;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}

2. 声明一个数组并赋值,将数组最大值和第一个元素交换位置

package com.easya;

import java.util.Arrays;

public class ZuoB {
    //声明一个数组并赋值,将数组最大值和第一个元素交换位置
    public static void main(String[] args) {
        int[] arr={4,2,3,6,5};
        int max=arr[0];
        int t=0,c;
        for(int i=0;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
                t=i;
            }
        }
        c=arr[t];
        arr[t]=arr[0];
        arr[0]=c;
        System.out.println(Arrays.toString(arr));
    }
}

3. 声明一个数组并赋值,将最大值和最小值交换位置,并打印结果

package com.easya;

import java.util.Arrays;

public class ZuoC {
    public static void main(String[] args) {
        //声明一个数组并赋值,将最大值和最小值交换位置,并打印结果
        int[] arr={4,2,3,6,5};
        int max=arr[0],min=arr[0];
        int t=0,c=0;
        for(int i=0;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
                t=i;
            }
            if(min>arr[i]){
                min=arr[i];
                c=i;
            }
        }
        int k;
        k=arr[t];
        arr[t]=arr[c];
        arr[c]=k;
        System.out.println(Arrays.toString(arr));
    }
}

4.声明一个数组并赋值,求这个数组所有元素之和

package com.easya;

public class ZuoD {
    public static void main(String[] args) {
        //声明一个数组并赋值,求这个数组所有元素之和
        int[] arr={1,2,3,4,5};
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum=sum+arr[i];
        }
        System.out.println(sum);
    }
}

5.声明一个二维数组并赋值,求这个数组所有元素之和

package com.easya;

public class ZuoE {
    public static void main(String[] args) {
        //声明一个二维数组并赋值,求这个数组所有元素之和
        int[][] arr=new int[3][4];
        int sum=0;
        int a=0;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                arr[i][j]=a;
                a++;
            }
        }
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                sum=sum+arr[i][j];
            }
        }
        System.out.println(sum);
    }
}

6.声明一个数组并赋值,声明一个变量并赋值,打印出这个变量的值在数组第一次出现的下标,如果没有出现过就打印-1

package com.easya;

public class ZuoF {
    public static void main(String[] args) {
        //声明一个数组并赋值,声明一个变量并赋值,
        // 打印出这个变量的值在数组第一次出现的下标,如果没有出现过就打印-1
        int[] arr={1,2,2,3,4};
        int t=2,c=0;
        for(int i=0;i<arr.length;i++){
            if(t==arr[i]){
                c=i;
                System.out.println(c);
            }else{
                System.out.println(-1);
            }
        }
    }
}

7.打印乘法口诀表

package com.easya;

public class ZuoG {
    public static void main(String[] args) {
        //打印乘法口诀表
        for(int i=1;i<=9;i++){
            System.out.println();
            for(int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+i*j+" ");
            }
        }
    }
}

8.打印出1000以内所有完数,质数

package com.easya;

public class ZuoH {
    public static void main(String[] args) {
        //打印出1000以内所有完数,质数
        int sum;
        for(int i=1;i<=1000;i++){
            sum=0;
            for(int j=1;j<i;j++){
                if(i%j==0){
                    sum+=j;
                }
            }
            if(sum==i){
                System.out.println("完数："+i);
            }
        }

        int t;
        for(int i=2;i<1000;i++){
             t=1;
            for(int j=2;j<i;j++){
                if(i%j==0){
                    t=0;
                    break;
                }
            }
            if (t==1){
                System.out.println("质数："+i);
            }
        }
    }
}