Core Java 基本数据类型，包装数据类型

Core Java学习笔记

Java语言执行过程:

源程序--->javac进行编译--->生成字节码文件-->java来执行

JDK JRE JVM

JAVA_HOME:JDK安装目录

CLASSPATH:告诉JVM从什么位置找字节码文件

PATH:让javac java可以在任何位置执行

对象，所以默认为null

java基本数据类型就8种，记住就好了。除了这些都是引用型的了。

java四类八种基本数据类型

第一类：整型 byte short int long
第二类：浮点型 float double

第三类：逻辑型 boolean(它只有两个值可取true false)

第四类：字符型 char

在栈中可以直接分配内存的数据是基本数据类型。
引用数据类型：是数据的引用在栈中，但是他的对象在堆中。
要想学好Java必须知道各种数据的在内存中存储位置。
对内存有了很好的了解，可以有助你分析程序。

字节：
boolean 布尔型 1/8
byte 字节类型 1
char 字符型 2 一个字符能存储一个中文汉字
short 短整型 2
int 整数类型 4
float 浮点类型（单精度） 4
long 长整形 8
double 双精度类型（双精度） 8

java中默认的整数类型是int类型，如果要定义为float型，则要在数值后加上l或L；
默认的浮点型也是双精度浮点，如果要定义为float型，则要在数值后加上f或F。

一个字节等于8位，一个字节等于256个数，就是-128到127一共256。
kB就是kBytes
Bytes就是“字节”的意思！
K就是千的意思，因为计算机是通过二进制来计算，10个1正好是1024
1111111111（二进制）=1024（十进制）
1Bytes（字节）=8bit（比特）
一个英文字母或一个阿拉伯数字就是一个字符，占用一个字节
一个汉字就是两个字符，占用两个字节。
一般讲大小是用Bytes，大写的“B”，讲网络速率是用bit，注意是小写的“b”。
例：一个文件有8MBytes
例：我下载文件的速率是256KB/s，即2Mbit，这通常就是我们宽带上网的速率。

基本数据类型自动转换

byte->short,char -> int -> long

float -> double

int -> float

long -> double

记住：小可转大，大转小会失去精度！！！

【基本数据类型对象包装类】

想要对基本类型数据进行更多的操作，最方便的方式就是将其封装成对象。

为啥呢？因为在对象描述中就可以定义更多的属性和行为对该基本数据类型进行操作。

【八种基本数据类型的包装类】

byte ――Byte

short ――Short

int ――Integer

long-----Long

float-----Float

double----Double

char----Character

boolean---Boolean

【基本数据类型变成对象包装类的好处】

可以将基本数据和字符串之间进行互相的转换。

如：int类型的取值范围是多少？

这就应该去查 Integer ―― Integer.MAX_VALUE ；

【基本数据类型包装类的主要作用： 进行基本数据类型和字符串之间的转换】

【基本类型数据 转为 字符串 的三种方式】

1. 基本数据类型对象包装类中的方法 static String toString(基本类型);

2. String类中的方法： static String valueOf(基本类型)

3. 基本类型数据 +“ ”；

【重点要掌握的就是：】

字符串---->基本类型数据。

返回值类型――>基本类型 ；参数――>字符串。

基本数据类型 变量名 = 基本数据类型包装类.parseXxx(XxxString)；

Long l = Long.parseLong("4546545646546");
System.out.println(Integer.parseInt("23") + 1);

在八个基本类型对象包装类中只有一个对象没有parse方法，就是Character.

【类型转换错误】――NumberFormatException――数字格式异常――我碰到了，因为我多加了一个 空格。

【Integer中要掌握的方法】涉及到一个进制转换的问题。

十进制-->其他进制。

二进制：static String toBinaryString(int);

16进制：static String toHexString(int);

八进制：static String toOctalString(int);

其他进制――>转成十进制；

Integer.toString(6 , 2); 将6转换为二进制。
parseInt(intString , radix);

System.out.println(Integer.parseInt("110") , 2);

――――――――――――――――――――――――――――――――

【基本数据类型值 和 基本类型数据对象之间的转换】

使用构造函数――Integer（）；

即可以接受基本数值，也可以接收基本数值的字符串形式。

可以使用基本类型对象中的方法。 static Integer valueOf(int);

【基本类型的对象 和 基本数据类型数值】

int intValue();

如：

Integer i = new Integer(34);

int num = i.intValue( );

System.out.println(num);

――――――――――――――――――――――――――――――――――――――――――――

【如果两数被封装成了对象该如何比较呢？】

【 基本数据类型的比较――用比较运算符； 引用数据类型使用compareTo进行比较。】

int compareTo( Integer anotherInteger ) 在数字上比较两个Integer对象。

在数值上比较两个Integer对象。以0 正数 负数 比较两个数多的大小。

Integer a = new Integer(7);

Integer b = new Integer(5);
System.out.println(a.compareTo(b));

【重点】

对象想要进行比较，必须通过方法来完成，这个方法就是compareTo。
而很多对象都可以进行比较。所以这个方法定义在Comparable接口中。

想要对象具备比较功能，只要实现Comparable接口。

【练习题】。

――――――――――――――――――――――――――――――――――――――――――――――――

【基本数据类型对象包装类JDk1.5以后的新特性】――【自动拆箱，装箱】

简化书写。

Integer i = new Integer(5);

基本数据类型对象包装类，对象创建的简化写法Integer i = 5;

1. Integer i = 5;(其实在内存中也是通过 new Integer(5)这种方式创建的！)

这种方式成为――自动装箱，Integer.valueOf(5)自动完成了对象创建的动作。

2. 在进行 i = i + 5，运算时――

= 右边的i 会先转成基本数据值（自动拆箱）i.intValue()，其实质为：

i = i.intValue() + 5 ；然后再和5进行加法运算。

= 右边运算完的结果，再次被自动装箱变成Integer对象赋给i.

一旦简化就有弊端：多具备一个值null. 使用自动装箱拆箱时，要进行null的健壮性判断。

【实例】

Integer x = null;

x = x.intValue() + 4; x为null 不能调用方法，此时会发生：NullPointerException异常。

――――――――――――――――――――――――――――――――

Boolean b = true; boolean b = true;的区别

答：前者：类类型变量指向一个对象，true为一个对象；

后者：true为基本类型变量。

――――――――――――――――――――――――――――――――

在JdK1.5的新特性自动装箱中，如果数值在byte类型范围内（-128 ~ 127）。如果该对象数值重复出现

多个引用其实是指向同一个Integer对象，节省空间！但是超出了byte范围，都会生产新的Integer对象。

Integer m = 127;

Integer n = 127;

System.out.println( m == n); //true

System.out.println(m.equals(n)); //true

____________________________________

Object x = 5；Object x 接受到了一个Integer对象,自动装箱。

然而 Object不可以接受基本数据类型。

――――――――――――――――――――――――――――――――――――――

【面试题】――"34 9 -7 67 25"要求对这个字符串中的数值进行从小到大的排序，生成一个数值有序的字符串。

【必须会】

思路：

1. 把其中的数拿出来，――对字符串进行切割。

2. 对数进行排序

3. 再追加成字符串。

步骤：1.split;――这个方法我还没掌握，怎么用。

【】――数组排序

2.定义一个int数组 将 字符串数组――>int数组

3.对int数组排序；

4. 将int数组转成字符串数组。
代码体现：

/**
 * 需求："34 9 -7 67 25"要求对这个字符串中的数值进行从小到大的排序，生成一个数值有序的字符串。
 * @author Administrator
 *
 */
publicclass StringTestint {
/**
 * @param args
 */
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
//要操作的目标
 String s = "34 9 -7 67 25";
//用空格对原字符串进行切割，转成字符串数组；
 String[] s1 = s.split(" ");
//定义int[]数组，用来存放整型数据
int[] arr = newint[s1.length];
//将字符串数组转成int类型的数组。
for(int i = 0 ; i < s1.length; i++)
 arr[i] = Integer.parseInt(s1[i]);
//对int类型的数组进行排序
for(int i = 0 ; i < s1.length;i++){
for(int j = i+1 ; j < s1.length;j++){
if(arr[i] > arr[j]){
int temp = arr[i];
 arr[i] = arr[j];
 arr[j] = temp;
 }
 }
 }
//定义字符串缓冲区，并将int类型的数组转换为 字符串类型的数组。
 StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
if(i != arr.length - 1)
 sb.append(arr[i] + " ");
else
 sb.append(arr[i]);
 }
 System.out.println(sb);
 }
}

代码优化：

import java.util.Arrays;

publicclass WrapperTest2 {

privatestaticfinal String SPACE = " ";
/**
 * @param args
 */
publicstaticvoid main(String[] args) {

/*
 * 综合练习：
 * "34 9 -7 12 67 25"要求对这个字符串中的数值进行从小到大的排序，
 * 然后生成一个数值有序的字符串。
 *
 * 思路：
 * 1，看到排序，就想要到了数组
 * 2，那数组中的元素怎么获取呢？数值都在字符串中。
 * 3，先从字符串中获取到这些具体的数值。怎么获取呢？
 * 4，发现这个字符串居然有规律。数值之间都是由空格隔开的。
 * 可以对字符串进行切割。
 * 5，将获取的数据存储到数组中并排序，在将数组转成字符就可以了。哦了。
 *
 *
 * 步骤：
 * 1，将字符串切割成字符串数组。split。
 * 2，定义一个int数组将字符串数组中的元素转成整数存储到int数组中。
 * 3，对int数组排序。
 * 4，将int数组排序后转成一个字符串。
 *
 */

 String str = "34 9 -7 12 67 25";

 str = sortStringNumber(str);
 System.out.println(str);
 }

publicstatic String sortStringNumber(String str) {

//1，将字符串中的数值通过指定的规则进行切割获取字符串数组。
 String[] str_nums = toStringArray(str);

//2，将字符串数组转成int数组。
int[] nums = toIntArray(str_nums);

//3，对int数组排序;
 sortIntArray(nums);

//4，将int数组变成字符串。
return arrayToString(nums);
 }
/*
 * 将int数组变成字符串。
 */
privatestatic String arrayToString(int[] nums) {
//1，创建字符串缓冲区。
 StringBuilder sb = new StringBuilder();
for (int i = 0; i < nums.length; i++) {
if(i!=nums.length-1)
 sb.append(nums[i]+SPACE);
else
 sb.append(nums[i]);
 }

return sb.toString();
 }

/*
 * 对int数组排序。
 */
privatestaticvoid sortIntArray(int[] nums) {
 Arrays.sort(nums);
 }

/*
 * 将字符串数组转成int数组。
 */
privatestaticint[] toIntArray(String[] str_nums) {
//1,先定义一个int数组。
int[] arr = newint[str_nums.length];

//2,对字符串数组进行遍历。
for (int i = 0; i < str_nums.length; i++) {
//将数组格式的字符串转成整数。存储到arr数组中。
 arr[i] = Integer.parseInt(str_nums[i]);
 }


return arr;
 }
/*
 * 将字符串转成字符串数组。
 */
privatestatic String[] toStringArray(String str) {

return str.split(SPACE);
 }



}