Day7知识总结

磕代码

已于 2023-07-19 10:21:12 修改

阅读量35

点赞数

分类专栏： java第一阶段文章标签： java 算法开发语言

于 2023-07-18 19:02:04 首次发布

本文链接：https://blog.csdn.net/m0_69480146/article/details/131792998

版权

java第一阶段专栏收录该内容

23 篇文章 0 订阅

订阅专栏

数据类型

基本数据类型

数值型：[ 整数类型 { byte(8位) 、short(16位)、int(32位)、long(64位)}，浮点类型{float(32位)、double(64位) } ]
字符型：char(16位)
布尔型：boolean(8位)

引用数据类型

类(class)、接口(interface)、数组

 	int a=10;
 	System.out.println(a); //输出a的数据值，基本数据类型
 	int[] arr=new int[10]; //数组创建后，每个元素初始化为0
 	System.out.println(arr);
 	//变量arr对应的数据的引用地址，arr保存的是对应的数据的引用地址
    //arr 引用类型
    Scanner scanner=new Scanner(System.in);
    System.out.println(scanner);//scanner 引用类型

变量不是基本数据类型，就是引用数据类型
1byte(字节)=8bit(位)

int类型

int范围

int 32位
值范围: -2147483648~2147483647

利用Integer 引用类型得到int范围最大值与最小值
Integer.MAX_VALUE
Integer.MIN_VALUE

//求数据类型范围
//方法一
int max=Integer.MAX_VALUE;
int min=Integer.MIN_VALUE;
//方法二
int max=(int) Math.pow(2,31);
int min=-(int) Math.pow(2,31)-1;

//int min=-(int) (Math.pow(2,31)+1); 
 //Math.pow(2,31)+[强转]  值溢出,出错

直接量(字面量)

程序中直接使用的数据

整数直接量默认为int，即范围不能超过int类型范围;
整数直接量后添加大写L(小写l),将直接量转换为long类型
浮点数直接量默认位double，范围不能超过double类型范围；
浮点数直接量后添加大写F(小写f),将直接量转换为float类型
直接量，可以是十进制、八进制[0 零]、十六进制[0x,0X]、二进制

int a=100;
//直接量默认int类型,该数据值10000000000范围超出int范围
//int b=10000000000; 
//添加大写L(小写l),将直接量转换为long类型;
long b=10000000000L; 

//100L、100 变量存储空间不同，100L会多消耗些存储空间
long e=100L; //100L是long长整型(64位)直接量
long f=100;  //100是int整型(32位)直接量
 
//a-10,b-11,c-12,d-13,e-14,f-15[十六进制]
int a1=0x10+0x0f;  //16+15=0x1f;

变量数据类型不同,在内存所占存储空间不同

关于整型直接量(int)可直接赋值给short、byte、char

直接量int类型直接赋值给[short、byte、char]类型变量

一个直接量int类型直接赋值给[short、byte、char]类型变量是可行的

只要赋予数据类型的值不超过该数据类型的取值范围，系统自动转换
例如 byte a=100 等价 byte a=(byte)100
系统自动强制转换
若赋予的值超过了数据类型的取值范围，则需手动强制转换数据类型，否则系统程序会报错
例如 byte a=128
报错：Type mismatch: cannot convert from int to byte
手动强制转换: byte a=(byte)128
强制转换溢出数据存在精度损失

//自动转换功能
//只要赋予数据类型的值不超过该数据类型的取值范围，系统自动转换;
//若赋予的值超过了数据类型的取值范围，则需手动强制转换数据类型
//手动强制转换,强制转换溢出数据,存在精度损失
byte c=(byte)200; 
//手动强制转换 200溢出byte数据范围,需手动强转
short a=79;  
//系统自动强制转换 等价于 short a=(short)79
byte b=80;  
//系统自动强制转换 等价于 byte b=(byte)80
byte b1=45;  
//系统自动强制转换 等价于 byte b=(byte)45

int类型的变量直接赋值给[short、byte、char]变量

一个int类型的变量直接赋值给[short、byte、char]变量,是错误的,需要进行类型的强制转换

int c1=100;
byte c3=c1; //手动强制转换
byte c3=(byte)c1;

 //系统自动强制转换，**int类型直接量**直接赋值给数据类型
byte c1=100;
手动强制转换,**int类型变量**直接赋值给数据类型
int c2=100;
byte c3=(byte) c2; //手动强制转换

两个[short、byte、char]变量相加、减、乘、除

两个[short、byte、char]变量相加、减、乘、除,会报错
由于系统防止两个数进行相加后的值有可能会溢出的危险，因此系统自动进行强制转换

byte b2=b+b1;
系统自动强制转换等价 byte b2=(int)b+(int)b1;
(int)b+(int)b1，返回的是int类型值，与byte类型变量不匹配
解决方法:计算后，手动强制转换数据类型，但存在溢出可能
byte b2=(byte) (b+b1);

byte b=80;  //系统自动强制转换 等价于 byte b=(byte)80
byte b1=45;  //系统自动强制转换 等价于 byte b=(byte)45
//byte b2=b+b1; 
 //系统自动强制转换 等价 byte b2=(int)b+(int)b1;
//(int)b+(int)b1 ——返回的是int类型值，与byte类型变量不匹配

//计算后，手动强制转换数据类型，但存在溢出可能
byte b2=(byte) (b*b1);

两个int相除(/)，取整

避免溢出

溢出不是编译错误，只是计算不准
正数溢出变负数;负数溢出变正数

int max=Integer.MAX_VALUE;
int min=Integer.MIN_VALUE;
System.out.println("————正数溢出变负数————"+max+1);
System.out.println(max+1);
System.out.println("————负数溢出变正数————");
System.out.println(min-1);

通过改变数据类型，避免溢出

//参与运算的结果，以数据类型大的范围为准
//int类型+long类型=long类型
System.out.println("通过改变数据类型，避免溢出");
System.out.println("最大值+1：  "+(max+1L));
System.out.println("最小值-1：  "+(min-1L));
//1为整型直接量(int),在1后面加L即(1L)是一个long类型的直接量

参与运算的结果，以数据类型大的范围为准
例如：int类型+long类型=long类型

数据类型范围从小到大
char<byte<short<int<long<float<double

int d1=30;
long d2=300;
float d3=2.2F; //字面量后面加F,表float类型
double d4=2.5; //字面量为小数，默认double类型
//int+long=long
long sum1=d1+d2;
//int+long+float=float
float sum2=d1+d2+d3;
//int+long+float+double=double
double sum3=d1+d2+d3+d4;

%运算符

取余，奇偶判断，整除，取数据每一位数字，公约数

long类型

时间

System.currentTimeMillis() long类型

数据类型转换

小类型范围变大类型范围自动转化
大类型范围转小类型范围需强制转换

long time=System.currentTimeMillis();
//int time1=time;//数据类型不匹配
int time1=(int) time; //强制类型转换，可能存在溢出

语法正确，不代表数据正确 --例如溢出
若计算表达式时，数据值溢出数据类型范围，有结果算出，但数据计算出的结果不正确

//三个1000相乘
//溢出:1000*1000*1000*10-是int,值溢出
long n1=1000*1000*1000*10;
//计算结果由大的数据范围决定，1000*1000*1000*10L
long n2=1000*1000*1000*10L;
//在计算至1000*1000*10000计算已溢出int范围
long n3=1000*1000*10000*10L;
//在运算前，确保运算结果为long——1000L*...此运算之后均为long类型
long n4=1000L*1000*10000*10;

在运算前，确保运算结果为想要的数据类型
例如:1000L*…
则运算之后均为想要的数据类型，规避计算时溢出

double、float类型

浮点数概念

浮点数不能精确运算，存在舍入误差，由于二进制中无法表示分数

double a1=3.0;
double a2=2.9;
System.out.println(a1-a2);
//0.10000000000000009舍入误差

BigDecimal、BigInteger用法

BigDecimal 可精确计算小数
BigInteger比long类型数据范围更大

//放入double类型本身不准确,因此需要放入字符串
//BigDecimal 可精确计算小数
//substract减 add加 divide除 multiply乘
BigDecimal big1=new BigDecimal("3.0");
BigDecimal big2=new BigDecimal("2.9");
BigDecimal bi1=big1.subtract(big2);
        
//比long类型数据范围更大
BigInteger bigint1=new BigInteger("92233720368547758070");
BigInteger bigint2=new BigInteger("100");
BigInteger bi2=bigint1.divide(bigint2); //相除取整

char类型

char基础

单引号(‘’)表示char类型，双引号表示String类型

char c1='a';//单引号表示char类型;
//char c2="a";编译错误 双引号表示String类型

字符类型==整数类型
16位无符号整数
char类型赋值(0~65535)
整数可参与运算
字符均有一个编码，这个编码是整数
无符号整数:无正负之分
ASCll Unicode编码
0-9:48~57
A-Z:65~90
a-z:97~122
JAVA中字符变量能存储中文
编码是Unicode,一个char类型占2个字节(即16比特),可以存储一个中文汉字

数据类型转换

char<byte<short<int<long<float<double

int a1=c1;
a1=c1+1;
char c2=(char)a1;
//int 4个字节 char 2个字节 大数据不能赋值给小数据 需要强转
//byte、short范围均有正负范围
short s1=99;
char c3=(char) s1;//short 短整型,2个字节 需要强转
byte s2=100;
char c4=(char) s2;//byte 1个字节 也需要强转

转义字符()

字符 ’ ’ [单引号]
字符串 " " [双引号]
对于不方便输出的字符，采用转义字符表示

退格(\b)
换行(\n)
回车(\r)
制表符(\t)
双引号(\")
单引号(\')
反斜杠(\)

//转义字符(\) 对于不方便输出的字符，采用转义字符表示
//退格(\b) 换行(\n) 回车(\r) 制表符(\t) 
//双引号(\") 单引号(\') 反斜杠(\\)
char k1='\\'; //得到\
char k2='\'';//得到'
char k3='\"';//得到"
char k4='\b';//得到退格

通过c1=‘a’，输出26个字符

'a’直接当做整型使用

//方法一
for (int i=c1;i<='z';i++)
     System.out.print((char) i+" "); //强制转换
System.out.println();
//方法二
for (int i=0;i<('z'-'a'+1);i++)
    System.out.print(c1++ +" ");
System.out.println();

char ‘1’,‘2’ 得到int 1

两个字符相加或相减可得到一个值，赋给int类型

//char '1','2' 得到int 1
int h4='2'-'1';

随机生产一个’A’-'Z’的字符并打印输出

随机生成min-max范围的数字
min+(int)(Math.random()*(max-min+1))
Math.round() 四舍五入
Math.floor()向下去整
Math.ceil()向上去整

int i='A'+(int) (Math.random()*('Z'-'A'+1));
System.out.println((char) i);

double r=Math.random();
 double rnum=r*('Z'-'A'+1)+'A';  //90-65+1=25 所以向上取整
System.out.println((char) Math.ceil(rnum));

boolean类型、

boolean类型只有true/false
不能用0或非0代替

Character、Integer

int Integer
char Character 定义char操作
Character.isLetter 判断是否是字符数字’0-9’
Character.isDigit 判断是否是字符字母(大小写均能)

System.out.println(Character.isDigit('1'));//true
System.out.println(Character.isDigit(4));//false

System.out.println(Character.isLetter('a'));//true
System.out.println(Character.isLetter('A'));//true
System.out.println(Character.isLetter(' '));//false