Day8知识总结

数据类型转换

char<byte<short<int<long<float<double
boolean类型不参与数据类型转换以及比较,只有两个值true与false

强制数据类型转换:可能会溢出，也可能损失精度

   //强制转换 大转小
   long data1=100000000000L;
   int data2=(int) data1; //溢出
   double pi=3.1415926535897932384;
   float f=(float)pi;//损失精度

隐式转换 小类型自动转大类型

 //隐式转换
short a3=a1;
int a4=a1;
long a5=a1;
double a6=a1;

强制转换 大类型手动转小类型

大类型不能直接赋值给小类型,使用强制转换语法规则,进行数据类型转换
char 键盘上某个字符值:0-127 char无符号(无负数)

byte a1=10;//10是直接量(字面量),可判断赋值是正确
int k=3;
// byte a2=k;
//k是变量,且k为int类型,不能直接复制给byte

int a7=-100000;
char a8=(char)a7;//强转
a7=a8; //隐士 自动转换

//char 键盘上某个字符值:0-127  char无符号(无负数)

运算结果由参与运算大的数据类型决定

数据(char,byte,short)运算之后，结果转换为int,运算后数据结果数据类型最小为int

byte b1=5;
byte b2=5;
//byte b3=b1+b2;   //编译错误
// 数据(char,byte,short)运算之后，结果转换为int
//数据计算,数据结果数据类型最小位int
//修改方式
byte b3=(byte) (b1+b2);//强制转换
int b4=b1+b2;//把结果赋值给能存放的数据类型中 

// 数据运算的结果，以范围大的为准
long c1=4+1L;//int直接量+long直接量=long数据类型
long c2=2L; double c3=3.0;
double c4=c2+c3 //long类型+double类型=double数据类型

算数运算符

+、-、*、/[整数运算取整] 、%[取余]、{+、-可当正数、负数} 、(加加)++、(减减)–

前后自增对变量本身来说都要加一;对于赋值运算种，会影响赋值的结果
(++n2)前自增: ++在变量前面,变量值先自增，再把自增后的变量值赋给n2
(n2++) 后自增:++在变量后面,先把n2的值赋出,n2再自增

//++ n++ ++n n变量本身会自增1
int n=5;
int n2=n++;
//后自增:++在变量后面,先把n的值赋给n2,n再自增
//前自增: ++在变量前面,变量值先自增，再把自增后的变量值赋给n2
System.out.println(n++);//等价int n2=n++

//前自减、后自减
int k2=5;
System.out.println(k2--); //输出k2,k2-1=4
System.out.println(--k2);//输出k2-1=3 k2=3
System.out.println(k2);//3

int b0=5;
int b1=b0-- + ++b0;//5+5(4+1)=10 b0=5
System.out.println(b1); //10
System.out.println(b0);//5

int b2=5;
int b3=--k2 + k2--; //4(5-1)+ 4(赋值k2当前值)=8 k2=4-1=3;

关系运算符

关系运算 > 、< 、>= 、<= 、!= 、== 、
关系运算结果为boolean类型

基本数据类型 可以直接使用关系运算;
引用类型不能直接使用关系运算
基本数据类型 变量中存储的是值
引用类型 变量中存储的是引用地址 无法比较

判断两个数组的元素是否一一对应

 public static void isSameNum(int arr1[],int arr2[]){
        Boolean v=true;
        if(arr1.length==arr2.length){ 
         //确保两个数组长度相等
            for(int i=0;i<arr1.length;i++){  
            //取出同一下表的数组元素
                if(arr1[i]!=arr2[i]) {
                //int数据类型比较 即基本数据类型比较
                    v=false;   //值不一样则结束循环
                    break;
                }
            }
        }
        else
            v=false;
        if(v)  //判断循环条件
            System.out.println("两个数组一一对应");
        else
            System.out.println("两个数组不是一一对应");
    }

产生10个100以内的随机整数，开平方(开根号)后小于等于6，就给该数加上一个100以内的随机整数

取整
四舍五入：Math.round()
向上取整：Math.ceil()
向下取整：Math.floor()

public static void randNum(int n2){
        double []n=new double[n2];
        for(int i=1;i<=n2;i++)
            n[i-1]=Math.ceil(Math.random()*100);
            //产生一个0-1的小数*100,向上取整
        System.out.println("原数组："+ Arrays.toString(n));
        for(int i=0;i<n.length;i++){
            if(Math.sqrt(n[i])<=6){   //产生的整数开根号
                n[i]=n[i]+Math.ceil(Math.random()*100); 
                //再产生一个向上取整的数相加
            }
        }
        System.out.println("修改后数组："+ Arrays.toString(n));
        //排序后
        Arrays.sort(n);
        System.out.println("排序后:"+Arrays.toString(n));
    }

逻辑运算符

逻辑运算 与[&& 短路与 、 & 逻辑与]、或[|| 短路或 、 | 逻辑或]、非[!]

短路逻辑:如果逻辑算由第一个表达式已得到了,就不计较第二个表达式
不短路逻辑:参与逻辑运算表达式都需要计算出结果,使用较少

int a=3,b=5;
boolean b1=a>b && a++>0; 
//a>b==false 在&&短路 第一个表达式决定了逻辑运算结果，为假
//即a=3[不执行a++]
boolean b2=a>b & a++>0; 
//a>b==false 在&逻辑 第一个表达式为假
//第二个表达式也要执行即a=4[执行a++]
boolean b3=a<b || a++>0; 
//a<b==true 在||短路 第一个表达式决定了逻辑运算结果，为真
//即a=3[不执行a++]
boolean b4=a<b | a++>0;
//a<b==true 在|l逻辑 第一个表达式为为真
//第二个表达式也要执行即a=4[执行a++]

赋值运算符

赋值运算 =

扩展运算符

+= 、 -= 、 /= 、 %= [中间未有空格]
当使用变量自己和某个数进行运算时，可使用扩展运算符，简化表达式

int sum=0;
int a,b,c;
c=100;
a=b=c;
sum+=a;
sum+=b;
sum=a+b;//这个无法使用扩展运算符

sum +=10 与 sum=sum+10 只是相似并不相等

byte b1=8;
b1+=3; //等价与 b1=(byte)(b1+3)
//b1=b1+5; 由于5是int数据类型,5+s是一个int类型的数据
//若赋值给byte类型存在类型不匹配

“+” 字符串拼接

运算符"+" ，用于整型、浮点型数据类型[数值型],加法运算
运算符"+"，用于字符串型，字符串拼接运算

String s=1+2+3+"";//"6"
String s1=""+1+2+3;//"123"
String s2=""+(1+2+3);//"6"
String s3="ab"+100;//"ab100"

三目运算符 X?Y:Z;

等价boolean表达式?表达式1[true满足]:表达式2[false不满足]
运算结果由参与运算大的数据类型决定

//数据比大小
int a2=5,b2=10;
int max=a2>b2?a2:b2;
System.out.println(max);
//int c2=a2>3?3:3.3; //运算结果由参与运算大的数据类型决定
double c2=a2>3?3:3.3;

五只猴子分桃

海滩上有一堆桃子，五只猴子来分
第一只猴子把这堆桃子凭据分为五份，多了一个,这只猴子把多的一个扔入海中,拿走了一份
第二只猴子把剩下的桃子又平均分成五份,又多了一个,它同样把多的一个扔入海中拿走了一份
第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子

方法一

先找到第一个猴子有多少，再根据条件x=x-(x-1)/5-1进行运算5次，若循环每次都能算的清，则是最少桃子数

//方法一:
public static void peachCount1(int n){
        int peach=6;
        while (true){
            int x=peach;
            boolean v=true;
            for(int i=1;i<=n;i++){
                if((x-1)%5==0){
                    x=x-(x-1)/5-1;
                }
                else {
                    v=false;
                    break;
                }
            }
            if (v)
                break;
            peach++;
        }
        System.out.println("桃子至少为:"+peach);
    }

方法二

最后剩余桃子数最小为4,从而递增；每一次递增均需满足(peach+1)*5-1)%4条件，否则从新选择最后桃子剩余数

public static void peachCount2(int n){
        int i=4;
        while (true){
            int peach=i;
            boolean v=true;
            for (int j=1;j<=n;j++){
                if(((peach+1)*5-1)%4==0){  //判断条件
                    peach=((peach+1)*5-1)/4;
                }
                else {
                    v=false;
                    break;
                }
            }
            if(v){
                System.out.println("桃子至少有:"+peach);
                break;
            }
            i++;
        }
    }