Java两周半速成之路（第十天）

灰太狼！！

已于 2024-03-06 14:37:22 修改

阅读量1k

点赞数 23

分类专栏： Java 文章标签： java 开发语言

于 2024-03-05 08:00:00 首次发布

本文链接：https://blog.csdn.net/weixin_52134189/article/details/136460053

版权

Java 专栏收录该内容

17 篇文章 2 订阅

订阅专栏

一.String和StringBuffer的相互转换

1.适用场景：

场景1：可以需要用到另一种类中的方法，来方便处理我们的需求

场景2：方法传参

场景一演示：


/*
    String和StringBuffer的相互转换

    A<-->B
    什么场景需要做转换操作：
    场景1：可以需要用到另一种类中的方法，来方便处理我们的需求
    场景2：方法传参

 */
public class StringBufferDemo1 {
    public static void main(String[] args) {
        //创建一个String对象
        String s1 = "hello";
        System.out.println("s1: " + s1);

        //String-->StringBuffer
        //1、使用StringBuffer构造方法
        StringBuffer sb1 = new StringBuffer(s1);
        System.out.println("sb1: " + sb1);


        //StringBuffer-->String
        //1、toString()方法
        StringBuffer sb2 = new StringBuffer("world");
        String s2 = sb2.toString();
        //2、截取
        String s3 = sb2.substring(0);

        System.out.println("--------------转换调用另一种类中的方法案例-------------------");
        //String对象字符串逆序
        String s4 = "abcd";
        System.out.println("s4: "+s4);
        //先转StringBuffer
        StringBuffer sb3 = new StringBuffer(s4);
        sb3.reverse();
        //再转回字符串String类型
        String s5 = sb3.toString();
        System.out.println("s5: "+s5);


    }
}

场景二演示：

（1） String类型作为方法参数传递

/*
    看程序写结果：
        String作为参数传递
        StringBuffer作为参数传递: 哪一个StringBuffer对象调用方法，哪一个就会改变

 */
public class StringBufferDemo5 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        change(s1, s2);
        System.out.println("s1: " + s1 + ", s2: " + s2);  //s1: hello, s2: world


    public static void change(String s1, String s2) {
        s1 = s2;
        s2 = s1 + s2;
        System.out.println("s1: " + s1 + ", s2: " + s2);   //s1: world, s2: worldworld
    }
}

内存图解：

（2）StringBuffer类型作为方法参数传递

演示：

/*
    看程序写结果：
        String作为参数传递
        StringBuffer作为参数传递: 哪一个StringBuffer对象调用方法，哪一个就会改变

 */
public class StringBufferDemo5 {
    public static void main(String[] args) {


        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        change(sb1, sb2);
        System.out.println("sb1: " + sb1 + ",sb2: " + sb2);    //sb1:hello     sb2:worldworld
    }

    public static void change(StringBuffer sb1, StringBuffer sb2) {
        sb1 = sb2;
        sb2 = sb1.append(sb2);
        System.out.println("sb1: " + sb1 + ",sb2: " + sb2); //sb1:worldworld   sb2:worldworld
    }

}

内存图解：

2.练习

题目：把数组拼接成一个字符串

/*
    把数组拼接成一个字符串,
 */
public class StringBufferTest {
    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33, 44, 55};
        StringBuffer sb1 = new StringBuffer();
        for (int i = 0; i < arr1.length; i++) {
            sb1.append(arr1[i]);
        }
        System.out.println(sb1);
//        System.out.println(sb1.toString());     //与上一条语句等价，上一条语句默认调用了toString()方法
    }
}

结果：1122334455

二.Arrays类概述及其常用方法

1.概述：

（1）与StringBffer类相似，不会新创建内存存放数据，而是在自身的"管道"中修改

（2）Arrays: 该类中没有构造方法，但是有很多静态方法，这种类我们称之为工具类

2.静态成员方法：

public static String toString(int[] a) 将数组以字符串的形式返回

public static void sort(int[] a) 快速排序，结果是升序的

public static int binarySearch(int[] a,int key) 二分查找返回查找到元素的索引

演示：


import java.lang.reflect.Array;
import java.util.Arrays;

/*
    Arrays: 该类中没有构造方法，但是有很多静态方法，这种类我们称之为工具类

    静态成员方法：
        public static String toString(int[] a)
        public static void sort(int[] a)
        public static int binarySearch(int[] a,int key)


 */
public class ArrayDemo {
    public static void main(String[] args) {
        //public static String toString(int[] a) 将数组以字符串的形式返回
        int [] arr1= {32,213,33,32,1};
        String s1 = Arrays.toString(arr1);
        System.out.println(s1);  //[32, 213, 33, 32, 1]      String类型

        //public static void sort(int[] a) 快速排序，结果是升序的
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));  //[1, 32, 32, 33, 213]

        //public static int binarySearch(int[] a,int key) 二分查找 返回查找到元素的索引
        //前提：序列必须是有序的
        System.out.println(Arrays.binarySearch(arr1, 32));  //2

        //如果找不到该元素，则会按照源码的逻辑返回某个值
        System.out.println(Arrays.binarySearch(arr1,465));    //-6

        /*
        binarySearch()源码：
           public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }
        
        binarySearch()方法返回值binarySearch0源码:

         private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }
         */

    }
}

三、包装类

1.概述：

java为了扩展每一个基本数据类型的功能，针对每一个基本数据类型都提供了一个对应的类，这些类统称为包装类

2.八大基本类型所对应的包装类：

byte: Byte short: Short int: Integer √ long: Long

float: Float double: Double boolean: Boolean char: Character √

3.Integer类

（1）概述：

<1> Integer 类在对象中包装了一个基本类型 int 的值

<2> 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法

（2）构造方法

public Integer(int value) 将基本数据类型int包装成引用数据类型Integer

public Integer(String s) 将String类型（例如"100"）包装成Integer类型（变为100）

演示：


/*
    java为了扩展每一个基本数据类型的功能，针对每一个基本数据类型都提供了一个对应的类，这些类统称为包装类
    byte: Byte
    short: Short
    int: Integer   √
    long: Long
    float: Float
    double: Double
    boolean: Boolean
    char: Character  √

    Integer类中的构造方法：
        public Integer(int value)
        public Integer(String s)


 */
public class BaoZhuangDemo {
    public static void main(String[] args) {
        //public Integer(int value) 将基本数据类型int包装成引用数据类型Integer
//        Integer i = new Integer(100);
        Integer i = 100;   //自动装箱   等价于上条语句
        System.out.println(i);
        System.out.println(i+1); //自动拆箱


        //public Integer(String s)       //将String类型（例如"100"）包装成Integer类型（变为100）
        Integer i1 = new Integer("100");
        System.out.println(i1);    // 100    Intefer类型

        Integer i2 = new Integer("xuyou");
        System.out.println(i2);    //NumberFormatException  报错的原因是不能将字符串类型的“xuyou”转化为数字的Intefer类型
    }
}

3.1 int类型和String类型的相互转换

public int intValue() 手动获取被包装的数值

public static int parseInt(String s) 将字符串转成数字

public static String toString(int i) int->String

public static Integer valueOf(int i) int->Integer

public static Integer valueOf(String s) String->Integer

演示：

/*
    Integer类中的成员方法：
        int类型和String类型的相互转换（字符串中的内容要是数值内容）
            int – String
            String – int

        public int intValue()       // 手动获取被包装的数值
        public static int parseInt(String s)       将字符串转成数字(String->int)
        public static String toString(int i)
        public static Integer valueOf(int i)
        public static Integer valueOf(String s)    

 */
public class IntegerDemo1 {
    public static void main(String[] args) {
        Integer i = 50;  //自动装箱
        System.out.println(i.toString()); //50   重写了toString()
        System.out.println(i.intValue()); //50   手动获取被包装的数值


        //public static int parseInt(String s)  将字符串转成数字
        //String->int
        String s1 = "100";
        System.out.println(Integer.parseInt(s1)); //100


        //public static String toString(int i)
        //int->String
        System.out.println(Integer.toString(100));  //  100     控制台输出100，其实是"100"


        //public static Integer valueOf(int i)
        //int->Integer
        int i1 = 20;
        System.out.println(Integer.valueOf(i1));     //20


        //public static Integer valueOf(String s)
        //String->Integer
        String s2 = "200";
        System.out.println(Integer.valueOf(s2)); //200

        //public static String toBinaryString(int i)      //转二进制
        Integer i2 = 30;
        String i3 = Integer.toBinaryString(i2);
        System.out.println("i3:"+i3);


        //如何将Integer->int
        Integer a1 = 100;
        System.out.println(a1.intValue());    //100   手动获取被包装的数值

        //如何将Integer->String     
        Integer a2 = 90;
        System.out.println(a2.toString()+1);    //901


    }
}

3.2进制转换

（1）常用的基本进制转换

public static String toBinaryString(int i) 转二进制

public static String toOctalString(int i) 转八进制

public static String toHexString(int i) 转十六进制

（2）十进制到其他进制

public static String toString(int i,int radix)

（3）其他进制到十进制

public static int parseInt(String s,int radix)

3.3JDK5的新特性

4.Character类

（1）概述：Character 类在对象中包装一个基本类型 char 的值

（2）构造方法：public Character(char value)

（3）Character类成员方法

public static boolean isUpperCase(char ch) 判断一个字符是否是大写

public static boolean isLowerCase(char ch) 判断一个字符是否是小写

public static boolean isDigit(char ch) 判断一个字符是否是数字

public static char toUpperCase(char ch) 转大写

public static char toLowerCase(char ch) 转小写

package com.shujia.day11;

/*
    char - Character

    public static boolean isUpperCase(char ch)
    public static boolean isLowerCase(char ch)
    public static boolean isDigit(char ch)
    public static char toUpperCase(char ch)
    public static char toLowerCase(char ch)

 */
public class CharacterDemo1 {
    public static void main(String[] args) {
       // public static boolean isUpperCase(char ch)    判断一个字符是否是大写
        Character c1 = 's';
        System.out.println(Character.isUpperCase(c1));   //false

        //public static boolean isLowerCase(char ch)      判断一个字符是否是小写
        System.out.println(Character.isLowerCase(c1));    //true

        //public static boolean isDigit(char ch) 判断一个字符是否是数字
        System.out.println(Character.isDigit(c1));       //false

        //public static char toUpperCase(char ch) 转大写
        System.out.println(Character.toUpperCase(c1));      //S

        //public static char toLowerCase(char ch) 转小写
        Character c2 = 'A';
        System.out.println(Character.toUpperCase(c2));    //A

    }
}

四.System类：和系统操作相关的工具类

成员方法:

public static void gc() 用于垃圾回收

public static void exit(int status) 强制退出程序

public static long currentTimeMillis() 获取时间戳（重要）

演示：

/*
    System类：和系统操作相关的工具类
    public static void gc()
    public static void exit(int status)          强制退出程序
    public static long currentTimeMillis()       获取时间戳          重要！！！

 */
public class SystemDemo {
    public static void main(String[] args) {
//                for (int i = 0; i < 10; i++) {
//            if(i==5){
                break;
//                System.exit(0);     //
//            }
//            System.out.println(i);
//        }
//
//        System.out.println("hello world");  //不打印该语句的原因是程序已退出

        System.out.println(System.currentTimeMillis()); //1709562014625

    }
}

五.Random类成员方法

public int nextInt()

public int nextInt(int n)

演示：


import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
//        int i = random.nextInt();     //-1055188392   随机生成一个数
//        System.out.println(i);

//        public int nextInt(int bound)  //随机产生一个整数，范围在 [0,bound)
        System.out.println(random.nextInt(100)+1);


    }
}

六.Date类概述及其方法

1.Date类概述

类 Date 表示日期时间，使用该类使用时间需要使用其构造方法创建对象。

2.构造方法

public Date() 将程序运行到此行时，此刻的时间

public Date(long date) 将指定的时间戳转成对应的时间

3.成员方法

public long getTime()

获取自1970年1月1日00:00:00 GMT开始到现在的毫秒数，也可以使用System.currentTimeMills()获取

public void setTime(long time)

设置日期时间值

演示：

import java.util.Date;

/*
    Date类：和日期有关的类

    SimpleDateFormat类：和日期格式化有关的类

    构造方法：
        public Date()  将程序运行到此行时，此刻的时间
        public Date(long date)  将指定的时间戳转成对应的时间

    成员方法
           public long getTime()
           public void setTime(long time)


 */
public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);         //Mon Mar 04 22:34:03 CST 2024
        long l = System.currentTimeMillis();
        System.out.println(l);             //1709562843667
        System.out.println(new Date(l));  //Mon Mar 04 22:34:03 CST 2024
    }
}

七、DateFormat类及其子类SimpleDateFormat类

(一)DateFormat类概述

（1）DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。

（2）是抽象类，所以借助其子类SimpleDateFormat进行创建或者使用其静态方法getDateInstance()进行

（3）成员方法：

public final String format(Date date) 将Date对象实例化格式化为目标形式

public Date parse(String source) 将字符串解析为日期，并返回这个日期的Date对象

（二）SimpleDateFormat类

1.概述：

该类是一个以与语言环境相关的方式来格式化和分析日期的具体类。

2、构造方法

public SimpleDateFormat()

public SimpleDateFormat(String pattern)

3.练习：将时间戳转为指定日期格式

演示：

import java.text.SimpleDateFormat;
import java.util.Date;

/*
    日期格式化类：SimpleDateFormat

    构造方法：
        public SimpleDateFormat(String pattern) yyyy年MM月dd日 HH时mm分ss秒

 */
public class SimpleDateFormatDemo {
    public static void main(String[] args) {
//        Date date = new Date();
//        System.out.println(date);  //Mon Mar 04 22:46:26 CST 2024
//
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//        String format = sdf.format(date);
//        System.out.println(format);   //2024年03月04日 22时46分26秒


        /*
         需求：将一个时间戳转成指定日期格式 1709535166924
          时间戳--Date--格式化
         */
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date1 = new Date(1709535166924L);
        System.out.println(date1);      //Mon Mar 04 14:52:46 CST 2024
        String format = sdf.format(date1);   
        System.out.println(format);    //2024年03月04日 14时52分46秒

    }
}

灰太狼！！

关注

23
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
Java两周半速成之路（第十天）

String和StringBuffer的互相转换，String和StringBuffer作为方法的参数，Arrays类，包装类，Random类，Data类和DateFromat类,SimpleDateFormat
复制链接

扫一扫

专栏目录