第一节 基本数据类型和String类
纲要：1.八种基本数据类型
2.数据类型之间的转换
3.String类
一．八种基本数据类型
整数类型：十进制存储格式
byte 字节型 8bits 表示范围：-128~127
short 短整型 16bits 表示范围：-2^15~2^15-1
int 整型 32bits 表示范围：-2^31~2^31-1
long 长整型 64bits 表示范围：-2^63~2^63-1
浮点型：十六进制存储格式，默认格式为double
float 浮点型 32bits
double 双精度浮点型 64bits
布尔型：
boolean 布尔型 true/false
字符型：
char 字符型 16bits
（数据值域说明：
1.一个bit是计算机可以存储的最小数据单位。即1位，不是0就是1。
2.1K=1024bit ， 1M=1024K ， 1G=1024M ）
/**
* 测试基本数据类型的取值范围
* @author zhouxiaoxiao
*
*/
public class range {
/**
* 程序主函数入口
*/
public static void main(String[] args) {
//byte 类型可取的最小值:-2^7
System.out.println("byte 类型可取的最小值: "+Byte.MIN_VALUE);
//byte 类型可取的最大值:2^7-1
System.out.println("byte 类型可取的最大值: "+Byte.MAX_VALUE);
//short 类型可取的最小值:-2^15
System.out.println("short 类型可取的最小值: "+Short.MIN_VALUE);
//short 类型可取的最大值:2^15-1
System.out.println("short 类型可取的最大值: "+Short.MAX_VALUE);
//int 类型可取的最小值:-2^31
System.out.println("int 类型可取的最小值: "+Integer.MIN_VALUE);
//int 类型可取的最大值:2^31-1
System.out.println("int 类型可取的最大值: "+Integer.MAX_VALUE);
//long 类型可取的最小值:-2^63
System.out.println("long 类型可取的最小值: "+Long.MIN_VALUE);
//long 类型可取的最大值:2^63-1
System.out.println("long 类型可取的最大值: "+Long.MAX_VALUE);
//float 类型可取的最小正值:2^(-149)=1.4E-45
System.out.println("float 类型可取的最小正非零值的常量: "+Float.MIN_VALUE);
//float 类型可取的最大正值:(2-2^(-23))2^127=3.4028235E38
System.out.println("float 类型可取的最大正有限值的常量: "+Float.MAX_VALUE);
//double 类型可取的最小正非零值:2^(-1074)=4.9E-324
System.out.println("double 类型可取的最小正非零值: "+Double.MIN_VALUE);
//double 类型可取的最大正有限值: (2-2^(-52))*2^1023=1.7976931348623157E308
System.out.println("double 类型可取的最大正有限值: "+Double.MAX_VALUE);
//boolean 类型只可取两个值：true 或 false
System.out.println("boolean 的true值: "+Boolean.TRUE);
System.out.println("boolean 的false值: "+Boolean.FALSE);
//char 类型可取的最小值： '\u0000'即Unicode值为0000的字符‘ ’。
System.out.println("char 类型可取的最小值: "+Character.MIN_VALUE);
System.out.println("char 类型可取的最小值的Unicode值为: "+(int)Character.MIN_VALUE);
//char 类型可取的最大值: '\uFFFF'即Unicode值为FFFF的字符‘?’。
System.out.println("char 类型可取的最大值: "+Character.MAX_VALUE);
System.out.println("char 类型可取的最大值的Unicode值为: "+(int)Character.MAX_VALUE);
}
}
结果如下：
二．数据类型之间的转换
数据范围大小：byte<short<char<int<long<float<double
1.boolean类型不能和其他任何类型进行相互转换。
2.小范围的类型转换成大范围的类型时，只有在整型转成char型时才需要强制转换，
其他情况下都可以通过赋值的方式直接转型。
代码如下：
/**
* 数据类型之间的转换，小范围转大范围
* byte<short<char<int<long<float<double
* @author zhouxiaoxiao
*
*/
public class minTRANSmax {
/**
* 程序主函数入口
*/
public static void main(String[] args) {
/**********boolean类型与其他类型之间的转换***********/
//boolean类型既不能通过直接复制转为其他类型，也不能通过强制转化转为其他类型
//boolean bool=true;
//byte b0=bool; ×
//byte b0=(byte)bool; ×
/**********byte型转其他大范围的***********/
byte b1=123;
//byte型可直接通过赋值转short型,int型,long型,float型,double型
//byte型转short型如下：
short s1=b1;
System.out.println("byte型值为：123，转换为short型后为："+s1);
//byte不能通过赋值直接转为char型
//char c1=b1; ×
//byte型经过强制转换转为char型
char c1=(char)b1;
System.out.println("byte型值为：123，强制转换为char型后为："+c1);
/********short型转其他大范围的*******/
short s2=1234;
//short不能通过赋值直接转为char型
//char c1=b1; ×
//short型经过强制转换转为char型
char c2=(char)s2;
System.out.println("short型值为：123，强制转换转为char型后的值为："+c2);
//short型可直接通过赋值转为int型,long型,float型,double型
//short型转int型如下：
int t2=s2;
System.out.println("short型值为：123，转换为int型后的值为："+t2);
/**********char型转为其他大范围的*********/
char c3='3'; //字符3的ASCII值为51
//char型可直接通过赋值转为int型,long型,float型,double型
//char型转int型如下：
int t3=c3;
System.out.println("char型字符为：3，转换为int型后的值为："+t3);
/********int型转其他大范围的*******/
int t4=12345;
//int型可直接通过赋值转为long型,float型,double型
//int型转为long型如下：
long lg4=t4;
System.out.println("int型值为：12345，转换为long型后的值为："+lg4);
/********long型转其他大范围的*******/
long lg5=123456;
//long型可直接通过赋值转为float型,double型
//long型转为float型如下：
float f5=lg5;
System.out.println("long型值为：123456，转换为float型后的值为："+f5);
/********float型转其他大范围的*******/
//浮点类型默认的格式为double型,因此不可以将12345.6直接赋值给float型
//float f6=12345.6; ×
float f6=(float)12345.6;
//float型可直接通过赋值转为double型
double d6=f6;
System.out.println("float型值为：12345.6，转换为double型后的值为："+d6);
}
}
结果如下：
3.大范围数据类型转换为小范围数据类型时
（1）都需要用强制转换，强制转换的格式如下：
数据类型 类型名=（数据类型）数据;
（2）大范围的数据类型转换为char型时若值未超过char型的最大范围，则会输出相应的字符，
若已经超出了char的最大范围，则不输出任何结果。
（3）浮点型转整数类型时，若没有超出整型的数据范围，则只会丢失小数点部分的数据。
若超出了整数类型的数据范围，则从“头”开始到对应位置即可，但数据已经不正确了。
例：对byte型，数据范围为-128~127,
-129已经超出了范围，它在byte中对应的数为127,-130则对应值126......以此类推
128也超出了数据范围，它在byte中对应的数据为-128，129则对应值-127......以此类推。
（4）整数数据类型之间的转换，若没有超出数据范围，则数据不产生影响。
若超出了整数类型的数据范围，也会从“头”开始到对应位置即可，但数据也会不正确。
代码测试如下：
/**
* 数据类型之间的装换，大范围转小范围
* byte<short<char<int<long<float<double
* @author zhouxiaoxiao
*
*/
public class maxTRANSmin {
/**
* 程序主函数入口
*/
public static void main(String[] args) {
/*******double型转成范围比它小的类型*********/
double d1=123456.3456;
//double型不能直接转为float型，必须通过强制转型
//float f1=d1; X
float f1=(float)d1; //float精度比double低，会有一些小数点丢失
System.out.println("double型的数据值为：123456.3456，强制转为float型后的值："+f1);
//double转为整型时也必须用强制转型，若值未超过整型的最大范围，则只会丢失小数部分的值
//long lg1=d1; X
long lg1=(long)d1;
System.out.println("double型的数据值为：123456.3456，强制转为long型后的值："+lg1);
//double转为整型时，若超过了整数的最大范围，则从头开始数，输出对应的值
//short s1=d1; X
short s1=(short)d1;
System.out.println("double型的数据值为：123456.3456，强制转为short型后的值："+s1);
//double转为char型时也必须用强制转型，若值未超过char型的最大范围，则会输出相应的字符
//若已经超出了char的最大范围，则不输出任何结果
//char c1=d1; X
char c1=(char)d1; //d1已经超出了最大范围
System.out.println("double型的数据值为：123456.3456，强制转为char型后的值："+c1);
//double型不能转为boolean型
//boolean bool=d1; X
//boolean bool=(boolean)d1; X
/*******float转为范围比它小的类型*********/
float f2=(float)1234.5;
//float转为整型时也必须用强制转型，若值未超过整型的最大范围，则只会丢失小数部分的值
//long lg2=f2; X
long lg2=(long)f2;
System.out.println("float型的数据值为：1234.5，强制转为long型后的值："+lg2);
//float转为整型时，若超过了整数的最大范围，则从头开始数，输出对应的值
//byte b2=f2; X
byte b2=(byte)f2;
System.out.println("float型的数据值为：1234.5，强制转为byte型后的值："+b2);
//double转为char型时也必须用强制转型，若值未超过char型的最大范围，则会输出相应的字符
//若已经超出了char的最大范围，则不输出任何结果
//char c2=f2; X
char c2=(char)f2; //f2没有超出最大范围
System.out.println("float型的数据值为：1234.5，强制转为char型后的值："+c2);
//double型不能转为boolean型
//boolean bool=f2; X
//boolean bool=(boolean)f2; X
/*******long转为范围比它小的类型********/
long lg3=1234;
//long型转成范围比它小的整型时必须用强制转换，若没有超过最大值，则数据不影响
//int t3=lg3; X
int t3=(int)lg3;
System.out.println("long型的数据值为：1234，强制转为int型后的值："+t3);
//long型转为范围比它小的整型时，若超过了整数的最大范围，则从头开始数，输出对应的值
//byte b3=lg3; X
byte b3=(byte)lg3;
System.out.println("long型的数据值为：1234，强制转为byte型后的值："+b3);
//long转为char型时也必须用强制转型，若值未超过char型的最大范围，则会输出相应的字符
//若已经超出了char的最大范围，则不输出任何结果
//char c3=lg3; X
char c3=(char)lg3;
System.out.println("long型的数据值为：1234，强制转为char型后的值："+c3);
//long型不能转为boolean型
//boolean bool=lg3; X
//boolean bool=(boolean)lg3; X
/*******int转为范围比它小的类型********/
int t4=123;
//int型转成范围比它小的整型时必须用强制转换，若没有超过最大值，则数据不影响
//若超过了整数的最大范围，则从头开始数，输出对应的值
//byte b4=t4; X
byte b4=(byte)t4; //123没有超出byte型的最大范围
System.out.println("int型的数据值为：123，强制转为byte型后的值："+b4);
//int转为char型时也必须用强制转型，若值未超过char型的最大范围，则会输出相应的字符
//若已经超出了char的最大范围，则不输出任何结果
//char c4=lg3; X
char c4=(char)t4;
System.out.println("int型的数据值为：123，强制转为char型后的值："+c4);
//int型不能转为boolean型
//boolean bool=t4; X
//boolean bool=(boolean)t4; X
/*******char转为范围比它小的类型********/
char c5='A';
System.out.println(c5);
//char型转整型时，若ASCII的值未超过整型的最大范围，则整型值直接为字符的ASCII值
//若超过了，则从头开始数，输出对应的值
//short s5=c5; X
short s5=(short)c5;
System.out.println("char型的字符为：A，强制转为short型后的值："+s5);
//byte b5=c5; X
byte b5=(byte)c5;
System.out.println("char型的字符为：A，强制转为byte型后的值："+b5);
//char型不能转为boolean型
//boolean bool=c5; X
//boolean bool=(boolean)c5; X
/************short型转byte型*************/
short s6=123;
//byte b5=s6; X
byte b6=(byte)s6;
System.out.println("short型的数据值为：123，强制转为byte型后的值："+b6);
//short型不能转为boolean型
//boolean bool=s6; X
//boolean bool=(boolean)s6; X
}
}
结果如下：
三．String类：String在java中是类，String类表示的是字符串。
String 类提供处理 Unicode 代码点（即字符）和 Unicode 代码单元（即 char 值）的方法。
1.创建并出示化字符串的方法：
（1）使用字符串常量直接初始化
（2）使用构造方法创建并初始化
/**
* 创建并初始化string对象
* @author zhouxiaoxiao
*
*/
public class st {
/**
* 程序主函数入口
*/
public static void main(String[] args) {
//方法一：使用字符串常量直接初始化
String s1="dcddjcidjm";
System.out.println("字符串常量直接初始化s1 :"+s1);
//输出结果：字符串常量直接初始化s1 :dcddjcidjm
//方法二：使用构造方法创建,然后再赋值
String s2=new String();
s2="jkdnvk";
System.out.println("构造方法创建,然后再赋值s2 :"+s2);
//输出结果：构造方法创建,然后再赋值s2 :jkdnvk
//方法三：使用构造方法创建的同时初始化
char [] ch={'a','p','p','l','e'};
String s3=new String(ch);
System.out.println("构造方法创建同时初始化s3 :"+s3);
//输出结果：构造方法创建同时初始化s3 :apple
}
}
2.String类中常用的方法：
2.1获取指定索引处字符，Unicode 代码点（Unicode值）及Unicode 代码点数的方法
public char charAt(int index);
public int codePointAt(int index);
public int codePointBefore(int index);
public int codePointCount(int beginIndex,int endIndex);
方法实现的代码及说明如下：
/**
* 指定索引处字符的方法
* @author zhouxiaoxiao
*
*/
public class st {
/**
* 程序主函数入口
*/
public static void main(String[] args) {
//初始化字符串
String s1="djdvdejkrkrhttmdd";
/***String类中的有关指定索引处字符的有关方法*****/
//返回指定索引处的char值
char c1=s1.charAt(3); //3表示索引值，索引值范围为：0~length-1
System.out.println("字符串 "+s1+"在索引值为3位置的字符为："+c1);
// 返回指定索引处的字符（Unicode 代码点）。
int t1=s1.codePointAt(3); //在索引值为3的字符为v，它对应的Unicode值为118
System.out.println("t1="+t1); //输出结果为：t1=118
//返回指定索引之前的字符（Unicode 代码点）。
int t2=s1.codePointBefore(3); //在索引值为3之前的字符为d，它对应的Unicode值为100
System.out.println("t2:"+t2); //输出结果为：t2=118
//返回此 String 的指定文本范围中的 Unicode 代码点数。
//文本范围为：beginIndex~endIndex-1
int t3=s1.codePointCount(3, 5); //3是开始的索引值，5是结束的索引值，则取定的范围只包含了3，4
System.out.println("t3:"+t3); //输出的结果为：t3=2
}
}
2.2比较两个字符串的方法：
public int compareTo(String anotherString);
public int compareToIgnoreCase(String str);
public boolean equals(Object anObject);
public boolean equalsIgnoreCase(String anotherString);
方法的实现及说明如下代码：
/**
* 比较两个字符串的方法
* @author zhouxiaoxiao
*
*/
public class st {
/**
* 程序主函数入口
*/
public static void main(String[] args) {
//初始化字符串
String s1="dejkriivjri";
String s2=new String("Dabcdjdhjhvd ");
String s3=new String("dejkr");
String s4="DEJKRIIVJRI";
//按字典顺序比较两个字符串
int t4=s1.compareTo(s2); //字符串之间不存在包含关系时，判断第一个不同的字符之间Unicode差值
System.out.println("t4:"+t4); //d的Unicode值为：100，D的为：68. 100-68=32, t4=32
t4=s1.compareTo(s3); //一个字符串是另一个字符串的前部分或整个部分时，为两个字符串的长度之差
System.out.println("t4:"+t4); //s3是s1的前面部分，两者长度相差6，所以t4=6
//按字典顺序比较两个字符串，不考虑大小写。
int t5=s1.compareToIgnoreCase(s4);
System.out.println("t5:"+t5); //不考虑大小写，s1和s4相同,长度相差0,所以t5=0
//将此字符串与指定的对象比较，考虑大小写。
boolean bool5=s1.equals(s2); //字符串相同则返回true不同则返回false
System.out.println("bool5:"+bool5); //结果为：true
//将此 String 与另一个 String 比较，不考虑大小写。
boolean bool6=s1.equalsIgnoreCase(s4); //字符串相同(不区分大小写)则返回true不同则返回false
System.out.println("bool6:"+bool6); //结果为：false
}
}
相关推荐
1.9 Java、Internet与万维网--------------------------------------------7 1.10 其它高级语言------------------------------------------------------8 1.11 结构化编程-----------------------------------...
- 对于基本数据类型参数，传递的是该值的副本；对于引用类型参数，传递的是对象引用的副本。 **4.11 理解静态static** - **静态属性**：类级别的属性，可以通过类名直接访问，而无需创建对象。 - **静态方法**：类...
Java支持多种数据类型，包括： - 基本类型：如`int`, `double`, `char`等。 - 引用类型：如`String`, `Array`, `Class`等。 **3.5 命名规则** - 类名首字母大写。 - 变量名和方法名首字母小写。 - 常量名全部大写...
17.3.1. 在基本数据类型和封装类之间的自动转换 17-69 17.4. 类型安全的枚举 17-70 17.5. 静态引入 17-71 17.6. C风格的格式化输出 17-72 17.7. Building Strings(StringBuilder类) 17-73 17.8. 可变长的参数 17-73 ...
Java支持以下几种数据类型： - **基本类型**：如int、float、char等。 - **引用类型**：如类、数组等。 ##### 3.5 命名规则 - 类名首字母大写。 - 变量名首字母小写。 - 方法名首字母小写，采用驼峰命名法。 ####...
- Java为每种基本数据类型提供了对应的包装类，如Integer、Double等。 **7.11 内部类** - **7.11.1 内部类的分类** - 成员内部类 - 局部内部类 - 静态内部类 - 匿名内部类 - **7.11.2 成员内部类** - 定义在...
- **基本数据类型**：如int、float、boolean等。 - **引用数据类型**：如类、接口、数组等。 ##### 3.5 命名规则 - 类名首字母大写。 - 变量名首字母小写。 - 常量全大写，单词之间用下划线分隔。 #### 第四部分：...
3.4 小结：基本数据类型—— Java中一切数据和运算的基础 63 3.5 习题 65 第4章 Java中的程序执行流程 67 教学视频：1小时57分钟 4.1 顺序执行 67 4.2 使用if-else让程序懂得判断 68 4.2.1 if语句 68 4.2.2 ...
Java中有两大类数据类型：原始类型和引用类型。 - **原始类型**包括`int`、`double`、`char`等。 - **引用类型**包括类、数组和接口。 **3.5 命名规则** - 变量名和方法名首字母小写，后面每个单词首字母大写...
对于单个文档，开发者可以提供JSON格式的数据以及对应的索引名和类型；批量插入则允许一次性处理大量数据，提高了性能。 ```java public void indexDocument(String index, String type, String id, Map<String, ...
3.4 小结：基本数据类型—— Java中一切数据和运算的基础 63 3.5 习题 65 第4章 Java中的程序执行流程 67 教学视频：1小时57分钟 4.1 顺序执行 67 4.2 使用if-else让程序懂得判断 68 4.2.1 if语句 68 4.2.2 ...
##### 2.4 基本数据类型与String类型转换 - **数据类型转String**：使用`String.valueOf()`方法或`+`操作符连接。 - **String转数据类型**：使用相应包装类的`parseXXX()`方法，如：`Integer.parseInt("123")`。 ##...
2.4 新建数据类型：类 2.4.1 字段和方法 2.5 方法、自变量和返回值 2.5.1 自变量列表 2.6 构建Java程序 2.6.1 名字的可见性 2.6.2 使用其他组件 2.6.3 static关键字 2.7 我们的第一个Java程序 2.8 注释和嵌入文档 ...
6.1 基本数据类型的包装类 167 6.2 处理对象 170 6.2.1 打印对象和toString方法 170 6.2.2 ==和equals比较运算符 172 6.3 类成员 175 6.3.1 理解类成员 175 6.3.2 单例（Singleton）类 176 6.4 final修饰符 ...