Java 学习日志（一）

1.明确包装类型与基本数据类型的区别。

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

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

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

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

基本类型对应的包装类byteByteshortShortintintegerlongLongfloatFloatdoubleDoublecharCharcterbooleanBoolean

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

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

如：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数组转成字符串数组。
代码体现：

[java] view plain copy

 print?

1. /** 
2.  * 需求："34 9 -7 67 25"要求对这个字符串中的数值进行从小到大的排序，生成一个数值有序的字符串。 
3.  * @author Administrator 
4.  * 
5.  */  
6. public class StringTestint {  
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.         // TODO Auto-generated method stub  
12.         //要操作的目标  
13.         String s = "34 9 -7 67 25";  
14.         //用空格对原字符串进行切割，转成字符串数组；  
15.         String[] s1 = s.split(" ");  
16.         //定义int[]数组，用来存放整型数据  
17.         int[] arr = new int[s1.length];  
18.         //将字符串数组转成int类型的数组。  
19.         for(int i = 0 ; i < s1.length; i++)  
20.             arr[i] = Integer.parseInt(s1[i]);  
21.         //对int类型的数组进行排序  
22.         for(int i = 0 ; i < s1.length;i++){  
23.             for(int j = i+1 ; j < s1.length;j++){  
24.                 if(arr[i] > arr[j]){  
25.                     int temp = arr[i];  
26.                     arr[i] = arr[j];  
27.                     arr[j] = temp;  
28.                 }  
29.             }  
30.         }  
31.         //定义字符串缓冲区，并将int类型的数组转换为 字符串类型的数组。  
32.         StringBuilder sb = new StringBuilder();  
33.         for (int i = 0; i < arr.length; i++) {  
34.             if(i != arr.length - 1)  
35.                 sb.append(arr[i] + " ");  
36.             else  
37.                 sb.append(arr[i]);  
38.         }  
39.         System.out.println(sb);       
40.     }  
41. }  

代码优化：

[java] view plain copy

 print?

1. import java.util.Arrays;  
2.   
3. public class WrapperTest2 {  
4.   
5.     private static final String SPACE = " ";  
6.     /** 
7.      * @param args 
8.      */  
9.     public static void main(String[] args) {  
10.   
11.         /* 
12.          * 综合练习： 
13.          * "34 9 -7 12 67 25"要求对这个字符串中的数值进行从小到大的排序， 
14.          * 然后生成一个数值有序的字符串。 
15.          *  
16.          * 思路： 
17.          * 1，看到排序，就想要到了数组 
18.          * 2，那数组中的元素怎么获取呢？数值都在字符串中。 
19.          * 3，先从字符串中获取到这些具体的数值。怎么获取呢？ 
20.          * 4，发现这个字符串居然有规律。数值之间都是由空格隔开的。 
21.          *      可以对字符串进行切割。 
22.          * 5，将获取的数据存储到数组中并排序，在将数组转成字符就可以了。哦了。 
23.          *  
24.          *  
25.          * 步骤： 
26.          * 1，将字符串切割成字符串数组。split。 
27.          * 2，定义一个int数组将字符串数组中的元素转成整数存储到int数组中。 
28.          * 3，对int数组排序。 
29.          * 4，将int数组排序后转成一个字符串。  
30.          *  
31.          */  
32.           
33.         String str = "34 9 -7 12 67 25";  
34.           
35.         str = sortStringNumber(str);  
36.         System.out.println(str);  
37.     }  
38.   
39.     public static String sortStringNumber(String str) {  
40.           
41.         //1，将字符串中的数值通过指定的规则进行切割获取字符串数组。  
42.         String[] str_nums = toStringArray(str);  
43.           
44.         //2，将字符串数组转成int数组。   
45.         int[] nums = toIntArray(str_nums);  
46.           
47.         //3，对int数组排序;  
48.         sortIntArray(nums);  
49.           
50.         //4，将int数组变成字符串。   
51.         return arrayToString(nums);  
52.     }  
53.     /* 
54.      * 将int数组变成字符串。  
55.      */  
56.     private static String arrayToString(int[] nums) {  
57.         //1，创建字符串缓冲区。  
58.         StringBuilder sb = new StringBuilder();  
59.         for (int i = 0; i < nums.length; i++) {  
60.             if(i!=nums.length-1)  
61.                 sb.append(nums[i]+SPACE);  
62.             else  
63.                 sb.append(nums[i]);  
64.         }  
65.           
66.         return sb.toString();  
67.     }  
68.   
69.     /* 
70.      * 对int数组排序。  
71.      */  
72.     private static void sortIntArray(int[] nums) {  
73.         Arrays.sort(nums);  
74.     }  
75.   
76.     /* 
77.      * 将字符串数组转成int数组。  
78.      */  
79.     private static int[] toIntArray(String[] str_nums) {  
80.         //1,先定义一个int数组。   
81.         int[] arr = new int[str_nums.length];  
82.           
83.         //2,对字符串数组进行遍历。  
84.         for (int i = 0; i < str_nums.length; i++) {  
85.             //将数组格式的字符串转成整数。存储到arr数组中。   
86.             arr[i] = Integer.parseInt(str_nums[i]);  
87.         }  
88.           
89.           
90.         return arr;  
91.     }  
92.     /* 
93.      * 将字符串转成字符串数组。  
94.      */  
95.     private static String[] toStringArray(String str) {  
96.           
97.         return str.split(SPACE);  
98.     }  
99.       
100.       
101.   
102. }  

2.适当练习valueOf()、xxxValue()、parseXxx()方法。

3.类型转换（以下为该周作业）。

1. public class StudyDiary01  
2. {  
3.     public static void main(String[] args){  
4.   
5.         //String --> int  
6.         String s = "111";  
7.         int i1 = Integer.parseInt(s); //直接使用静态方法，不会产生多余的对象，但会抛出异常  
8.         System.out.println("String --> int : i1=" + i1);   
9.           
10.         int i2 = Integer.valueOf(s).intValue(); //Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象  
11.         System.out.println("String --> int : i2=" + i2);   
12.           
13.         int i3 = Integer.parseInt(s,10);//若int i = Integer.parseInt("123"，16);即可以看成i  = 1*16*16+2*16+3  
14.         System.out.println("String --> int : i3=" + i3 + '\n');    
15.   
16.   
17.         //int --> String   
18.         int j = 222;  
19.         String t1 = String.valueOf(j);//直接使用String类的静态方法，只产生一个对象  
20.         System.out.println("int --> String : t1=" + t1);   
21.           
22.         String t2 = Integer.toString(j);  //直接使用静态方法，产生新的对象，会抛出异常  
23.         System.out.println("int --> String : t2=" + t2);  
24.   
25.         String t3 = "" + j; //会产生两个String对象  
26.         System.out.println("int --> String : t3=" + t3 + '\n');   
27.   
28.   
29.         //int --> Integer  
30.         int m = 333;  
31.         Integer n1 = m; //装箱  
32.         System.out.println("int --> Integer：n1=" + n1);  
33.   
34.         Integer n2 = new Integer(n1);  
35.         System.out.println("int --> Integer：n2=" + n2);  
36.   
37.         Integer n3 = Integer.valueOf(n2);  
38.         System.out.println("int --> Integer：n3=" + n3 + '\n');  
39.   
40.   
41.         //Integer --> int  
42.         Integer x=444;  
43.         int y1 = x; //拆箱  
44.         System.out.println("Integer --> int：y1=" + y1);  
45.   
46.         int y2 = x.intValue();  
47.         System.out.println("Integer --> int：y2=" + y2);  
48.   
49.         int y3 = Integer.valueOf(x);  
50.         System.out.println("Integer --> int：y3=" + y3 + '\n');  
51.   
52.   
53.         //String --> Integer  
54.         String r = "555";  
55.         Integer k1  = Integer.valueOf(r);  //这种方法常用  
56.         System.out.println("String --> Integer：k1=" + k1);  
57.   
58.         Integer k2 = new Integer(r);  
59.         System.out.println("String --> Integer：k2=" + k2);  
60.   
61.         Integer k3 = Integer.parseInt(r);  
62.         System.out.println("String --> Integer：k3=" + k3);  
63.   
64.         Integer k4 = Integer.parseInt(r,10);  
65.         System.out.println("String --> Integer：k4=" + k4 + '\n');  
66.   
67.   
68.         //Integer --> String  
69.         Integer l = 666;  
70.         String z1 = String.valueOf(l);  
71.         System.out.println("Integer -->Stringf：z1=" + z1);  
72.   
73.         String z2 = l.toString();  
74.         System.out.println("Integer -->Stringf：z2=" + z2);  
75.   
76.         String z3 = "" + l;  
77.         System.out.println("Integer -->Stringf：z3=" + z3 + '\n');  
78.     }  
79.   
80. }

（1）String转换为int
int i = Integer.parseln(str);
int i = Integer.valueOf(str).intValue();
（2）String转换为Integer
  两种构造方法的区别，Character只有一种
（3）int转换为String
  String s = s.valueOf(i);
  String s = Integer.toString(i);
  String s = “”+i;
（4）int转换为Integer
（5）Integer转换为String
（6）Integer转换为int
（7）Integer转换为String

4.通过键盘输入，初始化两个数将这两个数值交换后，输出显示后的数据。

1. import java.util.Scanner;  
2.   
3. public class StudyDiary02  
4. {     
5.     public static void main(String[] args){  
6.         Scanner input = new Scanner(System.in);  
7.         System.out.print("请输入第一个值:");  
8.         int a = input.nextInt();  
9.         System.out.print("请输入第二个值:");  
10.         int b = input.nextInt();  
11.         System.out.println("交换之前的两个值为"+a+","+b);  
12.         int c;  
13.         c = a;  
14.         a = b;  
15.         b = c;  
16.         System.out.println("交换之后的两个值为"+a+","+b);  
17.         }  
18. }  

5.定义一个五位整数，求各个位上的数的和

1. import java.util.Scanner;  
2.   
3. public class StudyDiary03  
4. {  
5.     public static void main(String[] args) {  
6.     Scanner in  = new Scanner(System.in);  
7.     System.out.print("请输入一个五位整数：");  
8.     int i = in.nextInt();  
9.     int sum = 0;  
10.     if (i < 10000 || i > 99999) {  
11.         System.out.println("输入有误！");  
12.         } else {  
13.             for (int j = 0; j < 5  ; j++ ) {  
14.                 sum +=  i % 10;  
15.                 i = i / 10;  
16.                 }  
17.                 System.out.println("该五位整数各位数上之和为sum=" + sum );  
18.                 }  
19.         }  
20. }   

6.根据天数计算周数和剩余的天数。天数通过键盘输入。

1. import java.util.Scanner;  
2.   
3. public class StudyDiary04  
4. {  
5.     public static void main(String[] args){  
6.     Scanner in = new Scanner(System.in);  
7.     System.out.print("请输入要转换的天数：");  
8.     int day = in.nextInt();  
9.     int week = day  /  7;  
10.     day =  day % 7;  
11.     System.out.println("为" + week + "周," + day + "天。");  
12.     }  
13. }  

7.学会使用API文档，看一看String类的所有方法。（ing......）
8.明确什么是引用类型，和C++的指针有什么异同，掌握java中数组的基本知识，例如（动态/静态）初始化，赋值，求大小，关于大小改变与C/C++中的区别。