上海传智播客JAVASE_day17学习笔记

最新推荐文章于 2023-05-19 18:28:11 发布

张伦琦

最新推荐文章于 2023-05-19 18:28:11 发布

阅读量399

点赞数

分类专栏： java基础学习之路

本文链接：https://blog.csdn.net/zhanglunqi45/article/details/38776909

版权

java基础学习之路专栏收录该内容

18 篇文章 0 订阅

订阅专栏

基本类型包装类

1、基本类型包装类介绍

Java中的基本类型：

byte short int long float double char boolean

主要用来开辟空间存放对应的类型的数据。基本类型的功能十分的单一，主要是负责数据的类型的。

于是java就对这些基本类型也进行对象的封装，把它们全部都变成对象，可以按照对象的方式来调用它们，并且给它们定义更多的属性和方法提供给我们使用。

基本类型包装类，它把对应的基本类型都使用一个类来包装。包装完之后，我们就可以使用当前这个类来操作对应的基本类型数据。并且给其中封装更多的行为。

基本类型包装类：

byte short int long float double char boolean

Byte Short Integer Long Float Double Character Boolean

基本类型对应的类类型（包装类）：其中大部分都是把基本类型的首字母大写，之后int对应的Integer，char对应的Character

Integer:它是对int类型的包装。其中提供了int类型范围能够存放的最大值和最小值的静态成员变量。

基本类型如何变成对应的对象类型

int x = 100;

可以使用Integer中的构造方法

Integer i = new Integer( x ); //x就被包装成对象类型了

通过保证类型中的方法，把基本类型转成包装类型

包装类型如何变成对应的基本类型

包装类型转成基本类型使用：xxxxValue方法

把字符串转成对应的基本类型：parseXxxx

基本类型、对象类型、字符串类型之间的相处转换

字符串转成包装类型：

在使用包装类型把一个字符串转成对应的包装类型时，字符串表示的数据一定要能够被转成对应的数据。如果无法转换就会发生NumberFormatException异常。

把基本类型转成字符串：

使用String类中的valueOf

使用+号连接：123+””;

使用对应的包装类型中的toString方法

总结：

基本类型转对象：使用对象类型的构造方法或使用包装类型中的valueOf

对象转基本类型：xxxxValue方法

字符串转成基本类型：使用包装类型中的静态方法parseXxxxx

字符串转对应的包装类型：包装类型的构造方法或者包装类型中的valueOf

2、JDK5的自动装箱和拆箱

publicclass Demo{

    publicstaticvoid main(String[] args) {

        method_2();

    }

    publicstaticvoid method_2() {
        Integer i = new Integer(127);

        Integer i2 = new Integer(127);

        System.out.println(i==i2);

       

        Integer i3 = new Integer(128);

        Integer i4 = new Integer(128);

        System.out.println(i3==i4);

       

        Integer i5 =127;

        Integer i6 =127;

        /*

         * 这里发生了自动装箱，在-128到127自动装箱的时候，jvm在初始化Integer这个类的时候

         * 就已经把-128到127之间这些数据提前存放Integer类型的数组中。

         * 当我们再把-128到127之间的这些数据采用自动装箱机制赋值给包装类型时，

         * 不会再创建包装类型的对象，而是从已经存在的缓存数组中把存在这些对象取出来直接赋值给当前的包装类型的引用。

         *

         */

        System.out.println(i5==i6);

       

        Integer i7 =128;

        Integer i8 =128;

        System.out.println(i7==i8);

    }

    publicstaticvoid method_1() {

        //把基本类型转成包装类型

        intx =123;

        Integer i = new Integer(x);

        Integer ii =Integer.valueOf(x);

        //JDK5之后给了自动装箱机制，可以把一个基本类型的数据直接赋值给一个对应的包装类的引用类型

        Integer ii2 = x;  //底层是把x先封装成Integer对象，然后在把这个对象的地址赋值给ii2

        //早期要把一个包装类型赋值给基本类型

        Double d = new Double(3.14);

        double dd =d.doubleValue();

        //自动拆箱

        doubledd2 = d;//自动拆箱，会把这个包装类型拆成对应的基本类型。

        //案例

        Integer i2 = new Integer(3);

       

        Integer i3 = i2 +456;//这里先把i2拆箱成基本类型，和456进行加法运算，运算的结果又被装箱成Integer

    }

}

3、基本类型包装类练习

/*

 *   需求： 有如下字符串，要求按照其字面值进行排序

 *     "23-2 -1 222 11 10 123 333 33 3"

 *      "23" "-2""-1" "222" "11" "10" "123""133" "33" "3"

 * 思路：

 *     1、首先需要把这个字符串按照空格类切割。切割后会形成一个字符串数组

 *     2、由于需求中要求按照字面值进行大小的排序。需要把这些字符串分别转成对应的基本类型数据，

 *     3、然后通过基本类型数据对其进行大小的比较。

 *     4、在把字符串数组中的每个字符串转成对应的基本类型数据，  可以使用Integer类中的parseInt方法

 *         转后的值也需要存放起来，需要定义一个int数组

 *     5、最后在int数组中的值转成字符串

 */

publicclass Test{

    publicstaticvoid main(String[] args) {

       

        String s = "23 -2 -1 222 11 10 123 333 33 3";

       

        String[] str_arr = split_method(s);

       

        int[] arr = parse(str_arr);

        //对其进行排序

        Arrays.sort(arr);

       

        String str = arrayToString(arr);

        System.out.println(str);

    }

    //主要负责把一个int数组转成字符串

    publicstaticString arrayToString(int[] arr) {

        //使用字符串缓冲区把int数组中的每个int值存放到缓冲区中，最后把缓冲区中的所有数据转成字符串

        StringBuilder sb = new StringBuilder();

        //循环取出arr中的每个int值

        for (inti = 0; i < arr.length; i++) {

            sb.append(arr[i]);

            sb.append(" ");

        }

        String s = sb.toString();

        returns.substring(0,s.length()-1);

    }

    //主要功能是把一个字符串数组转成对应的int数组，并返回这个int数组

    publicstaticint[] parse(String[] str_arr) {

        //定义一个和字符串数组长度相同的int数组，目的是把字符串数组中的所有字符串都转成int值存放在int数组中

        int[] arr = newint[str_arr.length];

       

        //取出字符串数组中的每个字符串，然后把其转成int值，存放在int数组中。

        for ( inti=0;i<str_arr.length;i++ ){

            //取出每个字符串，转成int值

            arr[i] =Integer.parseInt(str_arr[i]);

        }

       

        returnarr;

    }

    //主要负责把字符串切割成字符串数组

    publicstaticString[] split_method(String s) {

        returns.split(" ");

    }

}

其他api类

1、Math类介绍

/*

 * Math类介绍

 * 主要封装的和数学运算相关的功能。

 * Math类中的方法都是静态的，可以通过类名直接调用

 *    

 *     ceil(value):返回大于value的最小整数

 *     floor(value):返回小于value的最大整数

 *      round(value):返回四舍五入的值

 *      random() 产生一个伪随机数，这个数字在0~1之间

 */

publicclassMathDemo {

 

    publicstaticvoid main(String[] args) {

       

        System.out.println(Math.E);

        System.out.println(Math.PI);

       

        System.out.println(Math.ceil(3.54));

        System.out.println(Math.floor(3.54));

        System.out.println(Math.round(3.54));

        System.out.println(Math.random());

        System.out.println(Math.pow(2, 3));

        System.out.println(Math.sqrt(2));

       

    }

}

2、Random类介绍

/*

 * Random类介绍:

 *     这类是专门负责产生各种各样的伪随机数

 * Math类中的random方法，可以产生随机数。但是这个方法只能产生0~1之间的数据。

 * Random类是负责产生随机数的，它在java.util.包下

 */

 

publicclassRandomDemo {

    publicstaticvoid main(String[] args) {

        for( inti=0;i<6;i++ ){

            System.out.println((int)(Math.random()* 10));

        }

       

        //使用Random类产生随机数

        Random r = new Random();

       

        System.out.println(r.nextBoolean());

        System.out.println(r.nextDouble());

        System.out.println(r.nextFloat());

        System.out.println(r.nextInt());

        System.out.println(r.nextInt(6));

    }

}

3、Date类介绍

/*
 * Date:
 *     介绍是java.util包下的Date类，这个类是负责描述日期这类数据的。
 *     Date主要是描述当前时间毫秒值对象。
 *     它中的很多方法不利于国际化，已经被废弃。
 *
 * Date是把当前的毫秒值封装成Date对象。
 *     如何把一个毫秒值转成Date对象
 *         Date()它是把当前的时间点的毫秒值转成Date对象
 *         Date(long date) 把我们指定的一个毫秒值转成Date对象
 *         setTime(long time) 把当前的Date对象设置成指定的毫秒值对应的那个日期对象
 *        
 *     如何把一个Date对象转成毫秒值
 *         Date类中有个getTime方法，可以把一个Date对象转成毫秒值
 */

 

publicclassDateDemo {
    publicstaticvoid main(String[] args) {
        //创建Date对象
        Date d = new Date();
        d.setTime(1380000910915L);
//      Date d = new Date(1380000910915L);
        System.out.println(d);
        System.out.println(d.toGMTString());
        System.out.println(d.toLocaleString());
        System.out.println(d.getTime());

           }

}

4、DateFormat类介绍

DateFormat类：

这类位于java.text包下。

这个类是个抽象类，这个类不能直接new对象。

DateFormat类主要是把日期对象格式化成字符串数据

Date对象，通过DateFormat类，可以被格式化成字符串数据"xxxx-xx-xxhh:mm:ss"

DateFormat类还可以一个字符串数据解析成Date对象。

"xxxx-xx-xx hh:mm:ss" 解析成Date对象

格式化：把对象格式化成文本（字符串）

解析：把文本（字符串）变成对象

由于DateFormat类是抽象类，它不能创建对象，但是这个类对外提供部分的静态方法，这些方法可以获取到本类的对象。

getDateInstance方法有重载，在获取DateFormat对象的时候可以指定风格

DateFormat.FULL: 2014年8月22日星期五

DateFormat.LONG： 2014年8月22日

DateFormat.MEDIUM： 2014-8-22 是默认风格

DateFormat.SHORT: 14-8-22

在使用DateFormat类中parse方法来解析一个字符串数据的时候，字符串数据给定的格式必须和获取DateFormat对象时指定的风格一致，

这样才能够解析，否则解析失败。

//使用DateFormat类把字符串形式的日期数据解析成Date对象
    publicstaticvoid method_2() throwsParseException {
        //字符串形式的日期数据
        String time = "2014年8月22日  星期五";
        //获取DateFormat对象
        DateFormat df =DateFormat.getDateInstance(DateFormat.FULL );
               //解析字符串
        Date d  = df.parse(time);
        System.out.println(d);
         }
    //使用DateFormat类对日期进行格式化
    publicstaticvoid method_1() {
        //获取DateFormat对象
        //DateFormatdf = DateFormat.getDateInstance();
        //DateFormatdf = DateFormat.getDateInstance( DateFormat.SHORT );
        DateFormat df =DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM );
        //创建一个Date对象
        Date d = new Date();
        System.out.println(d);
        //对这个Date对象进行格式化
        String time = df.format(d);
        System.out.println(time);

    }

5、SimpleDateFormat类介绍

当我们想按照自己指定的风格来解析字符串数据或者格式化日期对象时，可以使用DateFormat的子类SimpleDateFormat。

/*
     *  演示使用SimpleDateFormat格式化Date对象
     * "xxxx年xx/xxHH时mm分ss秒"
     */
    publicstaticvoid method_4() {
        //获取Date对象
        Date d = new Date();
        //获取格式化对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM/dd HH时mm分ss秒");
        //对日期对象进行格式化
        String time = sdf.format(d);
        System.out.println(time);
    }

    /*
     * 演示使用SimpleDateFormat类解析指定的格式数据
     * "2014/08/22"  对应的格式："yyyy/MM/dd"
     * "2414/08/22 23:23:23"    "yyyy/MM/dd HH:mm:ss"
     */
    publicstaticvoid method_3() throwsParseException {
        //字符串形式的日期数据
        String time = "2414/08/22 23:23:23";
        //创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        //解析
        Date d = sdf.parse(time);
        System.out.println(d);

    }

6、日期格式化练习

/*
 * 需求：
 *     有2个字符串形式的日期数据，需要计算它们相距多少天？
 *         "2014年09/28 23时13分01秒"
 *         "2009-02月12日 12时02分01秒"
 *
 * 思路：
 * 要计算天数，首先需要把字符串形式的日期数据变成毫秒值，然后再通过毫秒值的相减得到时间差，然后再转成相距的天数。
 * 如何把字符串数据变成毫秒值呢？
 *     可以通过Date对象中的getTime方法，把一个Date对象转成毫秒值
 *     把字符串日期数据转成Date对象，可以使用SimpleDateFormat类完成
 */
publicclassDateTest {
    publicstaticvoid main(String[] args) throwsParseException {
        String s1_time = "2014年09/28 23时13分01秒";
        String s2_time = "2013-09月27日 23时13分01秒";
    
        //获取格式器
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM/dd HH时mm分ss秒");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM月dd日 HH时mm分ss秒");
      
        //解析字符串
        Date d1 = sdf1.parse(s1_time);
        Date d2 = sdf2.parse(s2_time);
       
        //把当前的日期对象转成毫秒值
        longtime_1 = d1.getTime();
        longtime_2 = d2.getTime();
      
        longday =(Math.abs(time_1 - time_2))/1000/60/60/24;
        System.out.println(day);
    }
}

7、Calendar类介绍

Calendar:

位于java.util包下。

这个类主要是用来描述日历数据。

Calendar类是个抽象类可以通过getInstance方法获取其实例。

它中定义很多静态成员变量，把日历上常见的年，月，日，时分秒，星期等数据都封装成静态的成员变量，

可以通过Calendar类直接获取其对应的数据。

在计算机中月份从0开始，0表示1月，1表示2月，11表示12月。

星期也是从0开始，0表示星期日，1表示星期一

我们获得了Calendar实例之后，就可以通过Calendar类中的get方法获取当前这个实例中封装的所有的数据。

在使用get方法时，需要使用Calendar类本身和其中的静态成员变量结合使用。

在Calendar类中有set方法，可以把Calendar实例中的对应的数据修改为我们想指定的具体年月日时分秒等信息

add方法可以在指定的成员变量上修改它对应的数据

publicclassCalendarDemo {
    publicstaticvoid main(String[] args) {
        method_2();
    }  
    /*
     * 任意一年的2月有多少天
     *
     * 思路：
     * 获取一个Calendar实例，然后通过set方法把当前的月份设置为3月1日。
     * 然后在使用add方法，让当前的月中的天数-1.这时再去获取当前的天数，一定是2月的最后一天。
     */
    publicstaticvoid method_2() {
       //获取Calendar实例
        Calendar c =Calendar.getInstance();
            //使用循环来提供年份
        for( intyear = 1998;year<=2100;year++ ){
            //使用set方法设置当前年月日
            c.set(year, 2,1);
            //使用add方法让天数-1
            c.add(Calendar.DAY_OF_MONTH, -1);
            System.out.println("当前"+year+"年的2月共计有："+c.get(Calendar.DAY_OF_MONTH));
        }
    }

    //Calendar方法演示
    publicstaticvoid method_1() {
        //获取Calendar实例
        Calendar c =Calendar.getInstance();
        System.out.println(c.get(Calendar.YEAR));
        //使用set方法来设置年月日
        //c.set(2011,12, 12);
        c.add(Calendar.YEAR, -1);
        System.out.println(c.get(Calendar.YEAR));
    }
}

8、jdk5可变参数

/*
 * 需求：定义功能计算2个数的和值
 *      定义功能计算3个数的和值
 *      定义功能计算4个数的和值
 *     .....
 *
 * 当有多个数据要传递给一个方法的时候，最好是把这个数据先封装到数组中，然后把这个数组直接传递给这个方法
 * 那么在方法中就可以通过数组取出这些数据。
 *
 *
 */

publicclass Demo{
    publicstaticvoid main(String[] args) {
        intsum = getSum(3, 4, 5);
        System.out.println(sum);
         // 定义一个数组
        int[] arr = {2, 3, 4, 5, 6, 7, 8, 9, 10 };
        intsum2 = getSum(2,3,1,4);
        System.out.println(sum2);
        /*
         * 当调用者需要传递多个数据给一个功能时，这时可以直接传递数据，
         *  这时在定义功能的时候，可以采用jdk5的可变参数机制来接收这些数据
         * 可变参数的格式：
         *      修饰符 返回值类型 方法名 ( 接收的数据类型 ... 变量名 )
         *      { }
         * 可变参数实际是方便了方法的使用者，使用者在调用方法的时候，不需要定义数组，直接传递数据即可。
         * 而方法的定义者，在定义功能的时候，需要使用  接收的数据类型 ... 变量名  接收参数
         * 其实方法上的变量名就是数组名
         *
         * 可变参数的细节：
         * 如果一个方法上有可变参数，还有其他的参数，这时可变参数必须写到整个参数列表的最后
         *  intx, int ... arr
         *   x 接收第一个参数，剩下的参数被arr接收
         */
     }
    // 定义功能，可以接收不确定个数据

    publicstaticint getSum(intx ,int ... arr) {
        intsum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        returnsum;
    }

     /* 定义功能可以接收一个数组，并且能够计算数组中元素的和值
    public static intgetSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++){
            sum+= arr[i];
        }
        return sum;
    }
    */
    // 计算2个数的和值

    publicstaticint getSum(inti, intj) {
        returni + j;
    }

    // 计算3个数的和值
    publicstaticint getSum(inti, intj, intk) {
        returni + j + k;
    }

    // 计算3个数的和值
    publicstaticint getSum(inti, intj, intk, intt) {
        returni + j + k + t;
    }

}

9、JDK5的foreach循环

* 高级for循环：

* 普通for循环格式：

* for( 表达式1 ; 表达式2 ; 表达式3 ){

* 循环体

* }

* 高级for循环的格式：

* for( 数据类型变量名：容器名 ){

* 循环体

* }

* 数据类型:是容器中存放的数据的类型

* 高级for循环主要是用来遍历容器的。比如数组，这时就可以使用高级for循环来遍历

* for( int x : arr ){

System.out.print(x+",");

}

这个循环其实在底层依然通过下标在访问arr数组中的数据，只不过是把arr中的数据取出来之后，直接存放在x变量中。

这时使用高级for循环，我们无法获取到数组的空间，以及数组的下标，仅仅只能获取到从数组空间中遍历出来的那个数据

高级for循环仅仅是用来遍历容器，如果要对容器中的数据进行复杂的操作，或者修改容器中的数据，这时必须使用普通for循环

publicclassForeachDemo {

publicstaticvoid main(String[] args) {

int[] arr ={5,1,2,0,8,4,3};

for (inti = 0; i < arr.length; i++) {

if( i!=arr.length-1 ){

System.out.print(arr[i]+",");

}else{

System.out.println(arr[i]);

}

System.out.println("=========================");

for( intx : arr ){

System.out.print(x+",");

x =100;

}

for (inti = 0; i < arr.length; i++) {

inttemp = arr[i];

System.out.println(temp+",");

temp =300;

}

张伦琦

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
上海传智播客JAVASE_day17学习笔记

基本类型包装类1、基本类型包装类介绍Java中的基本类型：byte short int long float double char boolean主要用来开辟空间存放对应的类型的数据。基本类型的功能十分的单一，主要是负责数据的类型的。于是java就对这些基本类型也进行对象的封装，把它们全部都变成对象，可以按照对象的方式来调用它们，并且
复制链接

扫一扫