Java实用类,包装类,日历类,日期类等工具类常用方法

第二章-实用类

1、枚举类型

枚举
枚举类更加直观,类型安全。使用常量会有以下几个缺陷:

  1. 类型不安全,可以随便赋值,而枚举类型的话,就只能传入枚举类中包含的对象。
  2. 没有命名空间。开发者要在常量命名的时候以固定格式开头,这样另外一个开发者再看这段代码的时候,才知常量的含义。

使用场景:
1)作为常量使用
枚举,可以把相关的常量分组到一个枚举类型里。

  public enum CarEnum {
        BMW, AUDI, BENZ
    }

备注:
enum和class、interface的地位一样
使用enum定义的枚举类默认继承了java.lang.Enum,而不是继承Object类。
枚举类的所有实例都必须放在第一行展示,不需使用new 关键字。自动添加public static final修饰。

2)使用Switch选择结构

// 当匹配枚举类型时,会自动强校验,case的值,必须是枚举类中声明的枚举类型变量
            CarEnum carEnum = CarEnum.BMW;
            switch (carEnum) {
            case BMW:
                System.out.println("喜提宝马740");
                break;
            case AUDI:
                System.out.println("喜提奥迪RS");
                break;
            case BENZ:
                System.out.println("喜提奔驰E200");
                break;

            default:
                break;
            }

3)枚举类内也可以定义属性和方法。注意必须加对应的属性和构造方法(还有普通方法来获取属性)才可以,否则报错

public enum CarEnum {
				//枚举类型实例必须放在第一行
                BMW("1", "宝马"), AUDI("2", "奥迪"),BENZ("3","奔驰");

                private String index;  
                private String name;

                // 构造方法  
                private CarEnum(String index, String name) {  
                    this.index = index;  
                    this.name = name;  
                }

                // 普通方法  
                public static String getNameByIndex(String index) {  
                    for (CarEnum car : CarEnum.values()) {  
                        if (car.index.equals(index)) {  
                            return car.name;  
                        }  
                    }  
                    return null;  
                } 

                public String getName() {
                    return name;
                }

                public void setName(String name) {  
                    this.name = name;  
                }

                public String getIndex() {
                    return index;
                }

                public void setIndex(String index) {
                    this.index = index;
                }

                /**
                 * 重新toString方法,输出枚举类型内容
                 */
                @Override
                public String toString() {
                    return "CarEnum{name="+ name + ",index=" + index + "}";
                }
            }

2、包装类

java中的基本数据类型int,double等不是对象,无法通过向上转型获取到Object提供的方法,而像String却可以,只因为String是一个类而不是一个类型。基本数据类型由于这样的特性,导致无法参与转型,泛型等过程。为了弥补这个缺陷,java提供了包装类,包装类都在java.lang包下面。

包装类作用:
1)提供了一系列实用的方法,作为基本数据类型对应的类类型,提供了一系列实用的对象操作,如类型转换。
2)集合不允许存放基本数据类型数据,存放数字时,要用包装类型。
3)包含了每种基本数据类型的相关属性,如最大值、最小值、所占位数等
//获取基本数据类型的相关属性
System.out.println(Byte.SIZE);//8
System.out.println(Byte.MIN_VALUE);//-128
System.out.println(Byte.MAX_VALUE);//127
4)所有包装类都是final类型,不能创建它们的子类
5)JDK1.5后,允许基本数据类型和包装类型进行混合数学运算,包装类并不是用来取代基本数据类型的,在基本数据类型需要用对象表示时使用

基本类型和包装类的对应关系:

  byte-Byte    int-Integer     short-Short     long-Long     float-Float 
  double-Double       boolean-Boolean            char-Character

基本数据类型的长度(位-bit)-- 一个字节占8位,char两个字节,可以存放汉字。

  System.out.println(Byte.SIZE);     //8
       System.out.println(Short.SIZE);    //16
       System.out.println(Integer.SIZE);  //32
       System.out.println(Long.SIZE);     //64
       System.out.println(Float.SIZE);    //32
       System.out.println(Double.SIZE);   //64
       System.out.println(Character.SIZE);//16

所有包装类都可将与之对应的基本数据类型作为参数,来构造它们的实例:

  Integer a = new Integer(100);
        Double b = new Double(100.00);
        Character c = new Character('A');
        Boolean d = new Boolean(true);

除Character类外,其他包装类可将一个字符串作为参数构造它们的实例:

  Integer a1 = new Integer("100");
        Double d1 = new Double("100.00");
        Boolean b1 = new Boolean("true");

注意:
1.Boolean类构造方法参数为String类型时,若该字符串内容为true(不考虑大小写),则该Boolean对象表示true,否则表示false

  Boolean d2 = new Boolean("True");
            Boolean d3 = new Boolean("TRUE");
            Boolean d4 = new Boolean("hello");

2.当包装类构造方法参数为String 类型时,字符串不能为null,且该字符串必须可解析为相应的基本数据类型的数据,否则编译通过,运行时NumberFormatException异常
java

   Integer a2 = new Integer("");// NumberFormatException: For input string: ""
            Integer a3 = new Integer(null);// NumberFormatException: null
            Integer a4 = new Integer("abc");// NumberFormatException: For input string: "abc"

3、包装类的常用方法

  1)valueOf
        Integer intValue = Integer.valueOf(21);
        除Character类外,其他包装类都可以如下操作:
        Integer intValue = Integer.valueOf("12");
    2) xxxValue()--包装类转换为基本数据类型
        Integer in1 = new Integer(100);
        int in2 = in1.intValue();
    3)toString()--以字符串形式返回包装对象表示的基本类型数据
        String str = Integer.toString(50);//自动装箱并调用toString()方法,这也是将基本类型转换为包装类的好处。
        String sex = Character.toString('男');
        // String str = String.valueOf(21); -- String类提供的方法
    4)parseXXX():把字符串转换为相应的基本数据类型数据(Character除外)
        int num1 = Integer.parseInt("100");
        System.out.println(num1); //100
        boolean bool = Boolean.parseBoolean("false");

4、包装类的自动装箱和拆箱

装箱:基本类型转换为包装类的对象
拆箱:包装类对象转换为基本类型的值

//自动装箱
int m = 10;
Integer in = m;
System.out.println(in);//10

//自动拆箱
Integer inn = new Integer(10);
int n = inn;
System.out.println(n);//10

5、String类

定义字符串两种方式:


    String s = "Hello World"; // 常用
    String s = new String("Hello World");

注意:字符串一经定义,不可以修改,因为是引用地址,所以重新赋值只是指向新的地址

常用方法:

 1)length()方法,确定字符串的长度,返回字符串中的字符数
        注意:是length()方法,数组是length属性

    2)equals()方法,比较存储在两个字符串对象的内容是否一致,区别于==(判断两个字符串在内存中的地址, 即判断是否是同一个字符串对象,object类中equals方法和==是一致的)。

    3)equalsIgnoreCase()方法:不区分大小写的判断值是否一致
    
        toLowerCase()方法:转换为小写

        toUpperCase()方法:转换为大写

    4) 字符串连接
        方式1:使用 + 
            String str = "aa"+"bb"+"cc";

        方式2:使用 concat 方法
            String str = "aa".concat("bb").concat("cc");

    5)字符串提取方法
        字符串中单个字符查找
            indexOf(int ch/String str) 
                查找当前字符串中字符或子串,返回字符或子串在当前字符串中从左边起首次出现的位置,若没有返回-1。
            indexOf(int ch/String str, int fromIndex)
                与第一种类似,区别在于该方法从fromIndex位置向后查找。
            lastIndexOf(int ch/String str)
                该方法与第一种类似,区别在于该方法从字符串的末尾位置向前查找,返回的位置仍然是左起位置。
            lastIndexOf(int ch/String str, int fromIndex)
                该方法与第二种方法类似,区别于该方法从fromIndex位置向前查找。

        字符串截取:substring方法可以提取字符串中的子串,该方法有两种常用参数:
                1)substring(int begin)
                    //该方法从begin位置(下标)起,从当前字符串中取出剩余的字符作为一个新的字符串返回。
                2)substring(int beg, int end)
                    //该方法从begin位置(下标)起,从当前字符串中取出到end-1位置的字符作为一个新的字符串返回。
            
        字符串去除首尾空格: trim()方法
            截去字符串两端的空格,但对于中间的空格不处理。

        字符串判断开始、结束
            statWith(String prefix)
            endWith(String suffix)
            用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同

        字符串判断是否包含子串
            contains(String str)
            判断子字符串是否被包含在字符串中,并返回一个布尔类型的值。

        字符串分割
            split()方法,将一个字符串分割为子字符串,结果作为字符串数组返回

6、StringBuffer对象

特点:
1)可变字符串类,创建StringBuffer类的对象后可以随意修改字符串的内容。
每个StringBuffer 类的对象都能够存储指定容量的字符串,如果字符串的长度超过了 StringBuffer 类对象的容量,则该对象的容量会自动扩大。
2)对字符串频繁修改(如字符串连接)时,使用StringBuffer类可以大大提高程序执行效率

语法:
StringBuffer() 构造一个空的字符串缓冲区,并且初始化为 16 个字符的容量。底层实现是16个字符长度的数组。
StringBuffer(int length) 创建一个空的字符串缓冲区,并且初始化为指定长度 length 的容量。
StringBuffer(String str) 创建一个字符串缓冲区,并将其内容初始化为指定的字符串内容 str,字符串缓冲区的初始容量为 16 加上字符串 str 的长度。

 输出字符串的容量大小
        capacity()方法返回字符串的容量大小
                
        使用
            1)toString -- 转换为String类型
            2)append() -- 用于向原有 StringBuffer 对象中追加字符串,常用方法 *
                append追加内容到当前 StringBuffer 对象的末尾,类似于字符串的连接。调用该方法以后,StringBuffer 对象的内容也发生了改变。
                使用 append() 方法时,如果长度超过了字符串存储空间大小就需要进行扩容,它会重新分配内存,创建一个更大的数组,这个数组的容量是原来的 2 倍 + 2 的大小,并将原先的数组复制过来,再丢弃旧的数组。

            3)插入字符串 -- 了解
                insert(1, "**");
                
            4)字符串倒序输出:
                reverse()方法,可以将字符串内容倒序
String,StringBuffer,StringBuilder比较

1)String是不可变对象,经常改变内容的字符串最好不要使用String,任何对String的改变都 会引发新的String对象的生成
2)StringBuffer是可变的字符串,字符串经常改变的情况可使用StringBuffer,更高效,任何对它所指代的字符串的改变都不会产生新的对象。
3)JDK1.5后提供了StringBuilder,等价StringBuffer。作为一个简易替代,他们的原理和操作基本相同,区别在于StringBuffer支持并发操作,线性安全的,适合多线程中使用。StringBuilder不支持并发操作,线性不安全的,不适合多线程中使用,而且大量字符操作时候,相对来说执行会快.
因此:
String:适用于少量的字符串操作的情况
StringBuilder:适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer:适用多线程下在字符缓冲区进行大量操作的情况

7、Math类

java.lang.Math类提供了常用的数学运算方法和两个静态常量E(自然对数的底数) 和PI(圆周率)

Math.abs(-3.5); //返回3.5  
        Math.max(2.5, 90.5);//返回90.5
        int random = (int) (Math.random() * 10); //生成一个[0,10)之间的随机数

注:Math类方法很多,需要使用直接看API文档即可,不需要全部掌握

8、Random类 – java.util.Random类

简单介绍使用示例,不需要全部掌握,用到时候查下文档即可

  //创建一个Random对象
        Random rand=new Random();
        for(int i=0;i<20;i++){
            //随机生成20个随机整数,并显示
            int num=rand.nextInt(10);//返回下一个伪随机数,整型的
            System.out.println("第"+(i+1)+"个随机数是:"+num);
        } 

9、日期操作类

1)java.util.Date类:表示日期和时间,提供操作日期和时间各组成部分的方法
Date对象本身所存储的毫秒数可以通过date.getTime()方法得到(long型的值);该函数返回自1970年1月1日 00:00:00 GMT(格林威治平时(Greenwich Mean Time))以来此对象表示的毫秒数(实际中国获取的,是需要加上时区的概念,中国8时区,即我们获取的是1970年1月1日 08:00:00)。

日期转换:
java.text.SimpleDateFormat类

  // Date指定格式:yyyy-MM-dd HH:mm:ss
                // yyyy -- 年
                // MM -- 月
                // dd -- 天
                // HH -- 24小时制 hh -- 12进制
                // mm -- 分钟
                // ss -- 秒
                // SSS -- 毫秒

                // 日期转字符串
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                // 创建一个date对象保存当前时间
                Date date = new Date();
                String dateStr = simpleDateFormat.format(date);
                
                // 字符串转日期:
                // 已知日期字符串,如何获取当前日期对象
                String date1 = "2010-10-01 11:11:11";
                try {
                    Date date2 = sdf.parse(date1);
                    System.out.println(date2);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                //调用parse()方法时 注意 传入的格式必须符合simpleDateFormat对象的格式,即"yyyy-MM-dd HH:mm:ss" 否则会报错!!

且抛出转换异常,需要捕获异常处理。

备注:
模式字母含义:只需要知道常用的几种(一定注意大小写,容易导致数据问题,比如数据库条件用24小时制,而代码处理用12小时制,会出问题)

y 年 Year
M 年中的月份 Month
D 年中的天数 Number
d 月份中的天数 Number
a Am/pm 标记 Text
H 一天中的小时数(0-23)
h am/pm 中的小时数(1-12)
m 小时中的分钟数 Number
s 分钟中的秒数 Number
S 毫秒数 Number

扩展:日期的比较,不能直接使用 > 或者 <

   // 方式一:getTime方法,比较两个日期的毫秒数大小
                long time1 = date1.getTime();
                long time2 = date2.getTime();
                if(time1 > time2){
                    System.out.println("第一个日期大于第二个日期");
                } else {
                    System.out.println("第一个日期小于第二个日期");
                }
                
    // 方式二:使用before方法,或者after方法
                if(date1.before(date2)){
                    System.out.println("第一个日期小于第二个日期");
                } else {
                    System.out.println("第一个日期大于第二个日期");
                }

            // 当前时间加1个小时

                Date date3 = new Date();
                System.out.println(sdf.format(date3));
                long time3 = date3.getTime();
                time3 += 60*60*1000;
                Date date4 = new Date(time3);
                System.out.println(sdf.format(date4));

2)日历Calendar类,java.util.Calendar
用于设置和获取日期/时间数据的特定部分

示例:

 // 创建一个代表系统当前日期的Calendar对象
            Calendar calendar = Calendar.getInstance();//默认是当前日期

        方法或属性:
            int get(int field) -- 返回给定日历字段的值
            // 获取年
            int year = calendar.get(Calendar.YEAR);
 
            // 获取月,这里需要需要月份的范围为0~11,因此获取月份的时候需要+1才是当前月份值
            int month = calendar.get(Calendar.MONTH) + 1;
 
            // 获取日
            int day = calendar.get(Calendar.DAY_OF_MONTH);
 
            // 获取时
            int hour = calendar.get(Calendar.HOUR);
            // int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示
 
            // 获取分
            int minute = calendar.get(Calendar.MINUTE);
 
            // 获取秒
            int second = calendar.get(Calendar.SECOND);
 
            // 星期,英语国家星期从星期日开始计算
            int weekday = calendar.get(Calendar.DAY_OF_WEEK);

设置指定日期:

  // 首先创建一个Calendar的对象,然后再设定该对象中的年月日参数来完成。
            // 创建一个Calendar对象
            Calendar c1 = Calendar.getInstance();
            // c1.set(int year,int month,int day)
            c1.set(2018, 11 - 1, 21);// month从0开始
            // 也可以单独设置:
            c1.set(Calendar.YEAR, 2017);
            // 通过日历类获取当前日期对象
            Date date = calendar.getTime();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(sdf.format(date));
 

Calendar和Date之间的转换:
1)Calendar转Date

     // Calendar-->Date
                Calendar calendar = Calendar.getInstance();  
                Date time = calendar.getTime();

2)Date转Calendar

   // 日历类和日期类型的转换
                String str1 = "2010-10-01 11:11:11";
                Date date2 = null;
                try {
                    date2 = sdf.parse(str1);
                    System.out.println(date2);
                } catch (ParseException e) {
                    e.printStackTrace();
                }

                // 通过setTime方法,将日期类转换为日历类
                Calendar calendar2 = Calendar.getInstance();
                calendar2.setTime(date2);
                // 获取当前多少周
                int weeks = calendar.get(Calendar.WEEK_OF_YEAR);
                System.out.println("当前周数:" + weeks);

            // 通过日历类,当前时间加一个小时
                Calendar calendar3 = Calendar.getInstance();
                calendar3.add(Calendar.HOUR, 1);
                System.out.println(sdf.format(calendar3.getTime()));

10.实用类,日期类,日历类常用方法代码示例

public class Test {
	public static void main(String[] args) {
		/**
		 * 包装类
		 */
		Integer i1 = new Integer("1");//包装
		Integer i = new Integer(1);//自动装箱
		int j =i;//自动拆箱
		System.out.println(j);
		
		
		Character c = new Character('c');
		//Character c = new Character("s");不支持char的包装类用字符串构造对象
		
		//Integer i2 =new Integer("");不可以,NumberFormatException异常
		//System.out.println(i2);
		
		Boolean b = new Boolean("TRue");//只要是true四个字母不分大小写都对,不是都错
		Boolean b1 = new Boolean(true);
		System.out.println(b.toString());
		
		Integer is = Integer.valueOf(100);//基本类型转包装类
		Character cc = Character.valueOf('c');
		
		int a = Integer.parseInt("11");//字符串转基本类型
		System.out.println(a);
		
		int aa = is.intValue();//包装类转基本类型
		System.out.println(aa);
		
		System.out.println(cc.toString());//所有包装类都有toString()方法
		System.out.println();
		System.out.println();
		System.out.println("-----------------------------------------------------------");
		System.out.println();
		System.out.println();
		/**
		 * Random工具类
		 */
		Random r1 = new Random();
		System.out.println(r1.nextInt(11));
		
		Random r2 = new Random(1);//种子相同,每次随机的值相同
		Random r3 = new Random(1);
		System.out.println(r2.nextInt());
		System.out.println(r3.nextInt());
		
		System.out.println();
		System.out.println();
		System.out.println("-----------------------------------------------------------");
		System.out.println();
		System.out.println();
		
		/**
		 * Math工具类
		 */
		System.out.println(Math.random()*10);//随机生成[0,10)
		System.out.println(Math.abs(-2));//取绝对值
		System.out.println(Math.max(1, 4));//取最大值
		
		System.out.println();
		System.out.println();
		System.out.println("-----------------------------------------------------------");
		System.out.println();
		System.out.println();
		
		/**
		 * StringBuffer工具类
		 */
		StringBuffer sbf = new StringBuffer();
		System.out.println(sbf.capacity());
		StringBuffer sbf1 = new StringBuffer(10);
		System.out.println(sbf1.capacity());
		StringBuffer sbf2 = new StringBuffer("abc");
		System.out.println(sbf2.capacity());
		System.out.println(sbf2.toString());
		System.out.println(sbf2.reverse());
		sbf2.append("sfa");
		System.out.println(sbf2);
		
		
		
		System.out.println();
		System.out.println();
		System.out.println("-----------------------------------------------------------");
		System.out.println();
		System.out.println();
		/**
		 * Date工具类
		 */
		Date date1 = new Date();
		long time = date1.getTime();//获得当前毫秒数
		System.out.println(time);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//模板
		System.out.println(sdf.format(date1));
		time+=60*60*1000;
		date1.setTime(time);
		System.out.println(time);
		System.out.println(sdf.format(date1));
		try {
			sdf.parse(sdf.format(date1));//date转换为字符串
			System.out.println(sdf.parse(sdf.format(date1)));//字符串转换为date
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		Date date2 = new Date();
		if(date1.getTime()>date2.getTime()){
			System.out.println("第一个时间大于第二个");
		}else{
			System.out.println("第一个时间小于第二个");
		}
		if(date1.before(date2)){
			System.out.println("第一个时间小于第二个");
		}else{
			System.out.println("第一个时间大于第二个");
		}
		if(date1.after(date2)){
			System.out.println("第一个时间大于第二个");
		}else{
			System.out.println("第一个时间小于第二个");
		}
		
		System.out.println();
		System.out.println();
		System.out.println("-----------------------------------------------------------");
		System.out.println();
		System.out.println();
		/**
		 * Calendar工具类
		 */
		Calendar calendar = Calendar.getInstance();
		int year =calendar.get(Calendar.YEAR);
		System.out.println(year);
		int month =calendar.get(Calendar.MONTH);//月的范围为0到11
		System.out.println(month+1);
		int day =calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(day);
		int weekday =calendar.get(Calendar.DAY_OF_WEEK);//从周天开始
		System.out.println(weekday);
		//指定日期
		calendar.set(Calendar.YEAR, 2011);
		calendar.set(2022, 11-1, 8);
		Date date = calendar.getTime();//将日历类转换为日期类
		SimpleDateFormat sdfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println(sdfs.format(date));
		
		calendar.setTime(date);//日期转换为日历类
		int weeks = calendar.get(Calendar.WEEK_OF_YEAR);
		System.out.println("当前周数:" + weeks);
		System.out.println(sdf.format(calendar.getTime()));
		calendar.add(Calendar.MONTH, 1);
		System.out.println(sdf.format(calendar.getTime()));
		
		
		System.out.println();
		System.out.println();
		System.out.println("-----------------------------------------------------------");
		System.out.println();
		System.out.println();
		/**
		 * String工具类
		 */
		//注意:String:字符串有下标,字符串初始化
		String s1 = new String("aa");
		String s2 = "bb";
		String s3 ="BB";
		//注意:为什么字符串是不可变的?因为String是个特殊类,final修饰,改变字符串就是改变地址的指向
		
		//1.s1.length()
		System.out.println(s1.length());
		//2.equals()由于String类重写了equals()方法,因此比较的是字符串的内容
		System.out.println(s1.equals(s2));
		//3.equalsIngoreCase()忽视大小写
		System.out.println(s2.equalsIgnoreCase(s3));
		//toUpperCase()转为大写字母
		System.out.println(s2.toUpperCase());
		//toLowerCase()转为小写字母
		System.out.println(s3.toLowerCase());
		//4.字符串的连接
		System.out.println(s1.concat("bb").concat("xz"));
		//5.字符数组转为字符串
		char c1[] = new char[]{'a','b','c'};
		String s4 = new String(c1);
		System.out.println(s4);
		//6,字符串查找子串,从左到右indexOf()
		String s5="asdlkjfsda";
		System.out.println(s5.indexOf(97));//传入的是ASCII码值,找到的是下标值,没有找到为-1
		System.out.println(s5.indexOf("b"));//传入字符串包含的字串,找到的是第一个字母的下标值,没有找到为-1
		System.out.println(s5.indexOf(97,0));//第一个参数是ASCII码值,第二个参数是下标值,返回值为下标值,没有找到为-1
		System.out.println(s5.indexOf("a",0));//第一个参数是字串,第二个参数是下标值,返回值为下标值,没有找到为-1
		//字符串查找子串,从右到左lastIndexOf()
		System.out.println(s5.lastIndexOf(97));//从右往左找第一个a出现的地方,传入的是ASCII码值,找到的是下标值,没有找到为-1
		System.out.println(s5.lastIndexOf("kj"));//从右往左传入字符串包含的字串,找到的是第一个字母的下标值,没有找到为-1
		System.out.println(s5.lastIndexOf(97, 4));//第一个参数是ASCII码值,第二个参数是下标值,返回值为下标值,没有找到为-1
		System.out.println(s5.lastIndexOf("kj", 3));//第一个参数是字串,第二个参数是下标值,返回值为下标值,没有找到为-1
		
		//7.字符串截取substring():包前不包后
		System.out.println(s5.substring(1));//第一种,截取下标从1开始到s5.length()
		System.out.println(s5.substring(2, 4));//第二中,截取下标从2到4的字符串,(包前不包后,2取的上4取不上)
		
		//8.trim()去两头空格,中间无法去掉
		String s6="  asd  sfsda   ";
		System.out.println(s6.trim());
		
		//9.startWith():以什么开头
		System.out.println(s6.trim().startsWith("a"));//以a开头
		System.out.println(s6.trim().startsWith("a", 1));//以a开头,下标为1
		//endsWith():以什么结尾
		System.out.println(s6.trim().concat(".java").endsWith("java"));//以java结尾
		
		//10.contains()是否包含a,可以用indexOf代替,不为-1则存在
		System.out.println(s6.contains("a"));
		
		//11.split()
		String s7 = "asfls!asd#adfj";
		String s8[] = s7.split("!|#");//以!与#划分
		System.out.println(Arrays.toString(s8));
		
		//12.chatAt(下标)
		String ss="";
		for(int n =0 ;n<s7.length();n++){
			char cc1 =s7.charAt(n);
			ss += Character.toString(cc1);
		}
		System.out.print(ss);
		//13.replace(oldStr,newStr)
		System.out.println();
		String ss8 = "sdjflmllfsa";
		System.out.println(ss8.replace("sdjf", "jklkl"));
		
		//13.toCharArray()
		char[] s9 = ss8.toCharArray();
		String ss9 = new String(s9);
		System.out.println(ss9);
		
		//14.将字符串打散为字节数组
		String ss0 ="dsafsdalakfj";
		byte[] bytes = ss0.getBytes();
		System.out.println(Arrays.toString(bytes));
		
		
		
		
		
		
		
		
		
		
	}
}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值