java常用类:1。包装类(以Integer类为例)2.String类 3.StringBuffer

java常用类:1。包装类(以Integer类为例)2.String类 3.StringBuffer包装类把八大基本数据类型封装到一个类中,并提供属性和方法,更方便的操作基本数据类型。包装类的出现并不是用于取代基本数据类型,也取代不了。包装类位于java.lang包中。Number类Number数值类型是byte、double、float、int、long和short类的抽象父类,提供把包装类转化成基本数据类型的方法(xxxValue)。In…

 包装

八大基本数据类型封装到一个类中,并提供属性和方法,更方便的操作基本数据类型。

包装类的出现并不是用于取代基本数据类型也取代不了。

 

包装类位于java.lang包中。

java常用类:1。包装类(以Integer类为例)2.String类 3.StringBuffer

 

Number 类

Number数值类型bytedoublefloatintlong short的抽象父类,提供包装类转化成基本数据类型的方法(xxxValue)

 

Interger int基本数据类型的包装类,在Integer内部封装了一个final int value属性。

 

package cn.test01;
//Integer 是int基本数据类型的包装类,在Integer内部封装了一个final int value的属性。
//toString()方法        valueOf方法   parseInt()方法   String和Int类型互相转换(数字字符串)  自动装箱,自动拆箱

//其他基本数据类型包装类:方法和Integer几乎一样。(具体请看jdk的说明书)
public class Test01 {
    public static void main(String[] args) {

        //Integer 属性
        System.out.println(Integer.MAX_VALUE);//输出结果:表示 int类型能够表示的最大值  
        System.out.println(Integer.MIN_VALUE);//输出结果:表示 int类型能够表示的最小值  
        
        //1.构造方法,把数据类型转换成包装类
        int a=10;
        String b="20";    //如果"a20"就有可能抛出异常
        Integer i1=new Integer(a);
        // 可能抛出NumberFormatException异常
        Integer i2=new Integer(b);
        System.out.println(i1.toString());//输出结果:10  toString()方法     toString()是Qbject的方法(是默认方法,可省略)
        System.out.println(i2.toString());//输出结果:20
        
        // 2.把包装类转化成基本数据类型
        Integer i3=new Integer(10);
        int c=i3.intValue();
        System.out.println(c);
        
        //3.Integer对象进行比较
        Integer i4=new Integer(20);
        Integer i5=new Integer(10);
        System.out.println(i4.equals(i5));  //比较俩个属性值,如果相等返回true,如果不相等返回false
        System.out.println(i4.compareTo(i5));
        //Comparable是一个接口,表示具有比较能力,对象可比较大小,此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。
        //在数字上比较两个Integer对象;如果i4=i5,则返回0,如果i4>i5,则返回正整数,数值为降序,如果i4<i5,则返回负整数,数值为升序
        
        //4.int<->Integer<->string,三者进行互相转换
        //int->Integer
        Integer i6=new Integer(10);
        Integer i7=Integer.valueOf(20);//valueOf方法  返回一个表示指定的 int值的 Integer实例。因为是静态的所以可以直接调用valueOf方法
        
        // Integer->int
        int d= i6.intValue();
        
        // String->Integer(数字字符串转换为Integer的对象)
        Integer i8 = new Integer("30");
        Integer i9 = Integer.valueOf("40");
        System.out.println(i9);//输出结果: 30  40
        
        // String->int(数字字符串转换为Int数据类型)
        int e = Integer.parseInt("50");   //  parseInt()方法:把字符串转换为int的方法
        System.out.println(e);  //输出结果: 50
        
        // int->String
        String str = Integer.toString(101010);//int转换为String类型
        String str2 = Integer.toString(8, 2);//(int a,你想要a的几进制)返回a的几进制的字符串的形式
        System.out.println(str);  //输出结果:字符串 101010
        System.out.println(str2); //输出结果:1000(是8的2进制)
        
        
        //自动装箱:把基本数据类型自动转化成对象的包装类的过程称为自动装箱(auto-boxing)
        Integer q=20;             //Integer q = new Integer(20);q=new Integer(20);把这个过程简写,直接把数值赋给q
        System.out.println(q);      //System.out.println(i2.toString());
        //自动拆箱:把包装类自动转化成对于的基本数据类型的过程称为自动拆箱(auto-unboxing)
        Integer w= new Integer(30);
        int r = w;      // 把(w.intValue();)直接简写为w
        System.out.println(r);
        /*注意:
        [1]自动装箱和自动拆箱是jdk1.5开始有的
        [2]不要过于频繁的使用拆装箱操作*/
    }
}

 

Comparable接口

Comparable 表示具有比较能力,对象可比较大小,此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

Comparable 定义a.compareTo(b),返回值表示

a.compareTo(b)

返回值

排序

a < b

负整数

升序

a = b

0

相等

a > b

正整数

降序

 

 

 

 

package cn.test01;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Arrays;

/**String:字符串本质
 * String 类代表字符串。Java 程序中的所有字符串字面值(如 "abc" )都作为此类的对象。 
 *字符串本质上是一个字符数组,它们的值在创建之后不能更改,所以字符串是常量;
 *可以把字符串看出是字符数组的包装类,内部声明一个private final char value[];
 *getBytes()
 *contains()  startsWith()  endsWith()方法
 *indexOf()  lastIndexOf() replace()方法
 *
 */
public class Test02 {
public static void main(String[] args) {
    String str1 = "abc";
    String str2 = "abc";
    System.out.println(str1 == str2);//输出结果:true
    //因为String是常量,所以字符串位于常量区,如果字符相等,那么在常量区可以共享一个字符串
    
    // 在堆区初始化一个空字符串(创建了一个空间,但空间内什么都没有)
    String str3 = new String();
    
    
    
    // 通过一个字节数组构建一个字符串
    byte[] bytes = {97,98,99};
    // 通过使用平台的默认字符集解码指定的 byte 数组
    System.out.println(Charset.defaultCharset());//输出结果:GBK  测试我们的平台使用的是什么类型的默认字符集解码
    String str4 = new String(bytes);   //把bytes数组通过GBK转换为字符串
    System.out.println(str2);         //结果:abc
    
    byte[] byte2 = {-42,-48};   //创建一个数组 //GBK是2个字节组成一个汉字  所以这是2个字节的,代表1个汉字
    String str5 = null;          //创建一个空字符串
    
    try {
   
   //因为有可能有异常,所以创建一个异常处理机制
        str5 = new String(byte2,"GBK");// 使用指定的字符集对字节序列进行解码(可以用其他字符集)
    } catch (UnsupportedEncodingException e) {
        
        e.printStackTrace();
    }
    System.out.println(str5);//输出结果:中     //GBK是2个字节组成一个汉字  所以这是2个字节的,代表1个汉字
    
    
    
    //需求:对一个utf-8的字节序列进行解码
    byte[] byte3 = {-28,-72,-83,-28,-72,-83};//utf-8是3个字节组成一个汉字  所以这是6个字节的utf-8代表两个汉字
    try {
        String str6 = new String(byte3,0,3, "UTF-8");//代表输出前面3个字节,后面三个字节不输出
        String str7 = new String(byte3, "UTF-8");
     System.out.println(str6);//输出结果:中
     System.out.println(str7);//输出结果:中中
    
    } catch (UnsupportedEncodingException e) {
        
        e.printStackTrace();
    }
    
    
    //把字符串编码成对于的字节系列
    String str21 = "abc";
    String str20 = "中国";        
    //使用utf8编码//byte[] bytes5 = str21.getBytes("UTF-8");
    // 使用默认的字符集(GBK)
    byte[] byte1 = str20.getBytes();
    byte[] byte4 = str21.getBytes();
    System.out.println(Arrays.toString(byte4));//输出结果:[97, 98, 99]  因为字母占一个字节
    System.out.println(Arrays.toString(byte1));//输出结果:[-42, -48, -71, -6]  中文占两个字节
    
    
    
    // 通过字符数组构建字符串
    char[] c1 = {'a','b','c','中','国'};
    String str8 = new String(c1);
    String str9 = new String(c1,0,3); //选择字符数组前3位构成字符串
    System.out.println(str8);  //输出结果:abc中国
    System.out.println(str9);   //输出结果:abc
    
    String str10 = new String("abc");  //有new的就是在堆区创立
    String str11 = "abc";
    System.out.println(str10 == str11);//返回结果:false  因为:它们一个在堆区,一个在常量区,而==是判断两个地址是否相等
     
     
    //字符串比较方法
    String str12 = "adc";
    String str13 = "Afc";
    System.out.println(str12.compareTo(str13));//大小写也要比较  
     //两种比较方法都是str12=str13为0;str12>str13返回正整数 ;str12<str13返回负整数,它们的区别在于一个忽略大小写比较,一个不忽略
    System.out.println(str12.compareToIgnoreCase(str13));// 忽略大小写比较
      
    
    // 字符串的连接
    String str14 = "abc";
    String str15 = "123";
   //String str16 = str14.concat(str15); 字符串连接的方法
    String str16 = str14+str15;
    System.out.println(str16);
    
    
    
    //查找、搜索字符串中是否包含其他子串
    String str17 = "hello world";
    // 是否包含子串:world  的方法
    System.out.println(str17.contains("world")); //输出结果:true
    //是否以he 开头的方法        
    System.out.println(str17.startsWith("he"));//输出结果:true
    //是否以world 结束的方法
    System.out.println(str17.endsWith("world"));//输出结果:true
    //字符串的第2个位置是否是ll开始
    System.out.println(str17.startsWith("ll", 2));//输出结果:true
    
    
    // 需求:判断一个文件是否是png图片(我们以是否以.png结尾来判断)
    String fileName = "logo.png";
    if(fileName.endsWith(".png")) {
    System.out.println(fileName+"是一张图片");    }//输出结果:true
        
    // 查找字符串
    //从左往右查找't'出现的位置(第一次出现),找到返回位置信息,没找到返回-1,
    System.out.println(str17.indexOf('t'));
    //从左往右查找3的位置之后(包含3)否是出现'o',如果是,返回第一次出现位置索引,如果没有则返回-1
    System.out.println(str17.indexOf('o',3));
    // 从右向左查找字符'o'第一次出现的位置,找到返回索引,没找到返回-1(同上反过来)
    System.out.println(str17.lastIndexOf('o'));
    //以上都可以查找char或者String
    
    
    //格式化字符串:通过指定占位符(%开始)格式化字符串
    float price = 998.126f;
    int a  = 10;
    int b = 2;
    //   %d(格式化整形)相当于占着一个位置空,format方法就是提前把格式准备好,而后依次把变量依号对坐
    String str18 = String.format("%d / %d = %d", a,b,(a/b));
    System.out.println(str18);//输出结果:10 / 2 = 5
    //%f(格式化浮点型)是四舍五入 ,%.nf(格式化浮点型四舍五入保留n为小数) %.2f四舍五入保留两位小数 
    String str19  =String.format("$%.2f", price);//输出结果:$998.12
    System.out.println(str19);
    //%c(格式化字符)%s格式化字符串
    
    
    
    //字符替换
    String str22 = "hello,world";
    String newStr1 = str22.replace('o', '8');  //通过replace方法把"hello,world"里的o替换成8
    System.out.println(newStr1);    //输出结果:hell8,w8rld
    
    String newStr2 = str22.replace("ll", "");//通过replace方法把"hello,world"里的ll替换成空
    System.out.println(newStr2);    //输出结果:heo,world
    
    // 需求:186-1234-2234
    String str23 = "186-1234-2234";
    System.out.println(str23.replace("-", ""));//输出结果:18612342234
    
    
    
    
    //正则表达式专门用于验证字符串是否符合特定的格式。
    String str24 = "6764";
    // 验证str4是否输入的是一串数字
    boolean r = str24.matches("\\d+");//通过matches方法
    System.out.println(r);//输出结果:true
            
    // 需求:abc123te23daf去掉数字
    String str25 = "abc123te23daf";
    String newStr5 = str25.replaceFirst("\\d+", "");//从左往右去掉第一个数字串
    String newStr6 = str25.replaceAll("\\d+", "");//去掉所有数字串
    System.out.println(newStr5);//输出结果:abcte23daf
    System.out.println(newStr6);//输出结果:abctedaf
    
    
    // 根据指定字符串拆分字符串
    String str26 = "abc-123";
    String[] arr = str26.split("-");
    System.out.println(Arrays.toString(arr));//输出结果:[abc, 123]
            
    // 需求:请快速构建一个26个小写英文字母的数组
    String str27= "abcdefghijklmnopqrstuvwxyz";
    String[] arr2 = str27.split("");        
    System.out.println(Arrays.toString(arr2));
    //输出结果:[, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
    
    
    // 根据正则拆分字符串(以数字组)
    String str28 = "abc123ta12asd";
    String[] arr3 = str28.split("\\d+");
    System.out.println(Arrays.toString(arr3));//输出结果:[abc, ta, asd]
            
            
    // 需求:请获取一个文件的文件名
    String fileName1 = "logo.png";
    String[] arr4 = fileName1.split("\\.");
    System.out.println(Arrays.toString(arr4));//输出结果:[logo, png]
    
    
    
    // 去掉前导空格和后导空格
    String str29 = "  abc   ";
    String newStr4 = str29.trim();
    System.out.println(str29.length());//输出结果:8
    System.out.println( newStr4);//输出结果:abc
    
    // 获取字符串的字符数组
    char[] arr5 = str29.toCharArray();
    System.out.println(Arrays.toString(arr5));//输出结果:[ ,  , a, b, c,  ,  ,  ]
            
            
    // 把其他数据类型转化为字符串
    String str30 = String.valueOf(10);
    System.out.println(str30);//输出结果:10

    
    
    
    
    //根据指定字符串拆分字符串
    String str31 = "abc123";
    
    
    String sub1 = str31.substring(0, 3);//(开始位置,结束的位置)// 含头不含尾
    System.out.println(sub1);//输出结果:abc
            
    String sub2 = str31.substring(3);//(开始位置)
    System.out.println(sub2);//输出结果:123
            
            
    //大小写转换
    String str32 = "Abc";
    System.out.println(str32.toUpperCase());//输出结果:ABC
    System.out.println(str32.toLowerCase());//输出结果:abc

     }
}

格式化字符串

通过指定占位(%开始)格式化字符串

%d

格式化整形

%f

格式化浮点型

%.nf

格式化浮点型四舍五入保留n为小数,

%c

格式化字符

%s

格式化字符串

 

package cn.test01;
/*StringBuffer
StringBuffer是字符的可变容器。可以在程序运行过程中向容器中添加、删除、修改字符。
StringBuffer 本质上是一个字符数组的包装类,并提供了很多方法向这个字符数组中添加、删除、修改字符。
StringBuffer 是线程安全的
StringBuffer工作原理:
StringBuffer 内部维护了一个字符数组,默认字符数组的长度是16.
当开发者向这个字符数组中添加元素时,如果有额外空间,直接添加到数组中,
如果没有额外空间,StringBuffer内部自动拓容,
拓容规则:当前容量*2+2,根据拓容的新空间,复制当前的数组内容到新数组中。

StringBuilder
同StringBuffer区别:
StringBuffer 是线程安全的,执行效率低,JDK1.0(用于多线程)
StringBuiler 就是为了缓解执行效率低而产生的,但线程不安全。JDK 1.5(用于单线程)
其他都一样
*/
public class Test03 {
public static void main(String[] args) {
    
    StringBuffer sb1 = new StringBuffer();
    // 【1】添加
    sb1.append("hello");
    sb1.append('d');
    
    // 返回字符串的长度
    System.out.println(sb1.length());//输出结果:6
    // 返回容器的大小
    System.out.println(sb1.capacity());//输出结果:16
    System.out.println(sb1);//输出结果:dhellod
    
    
    
    // 【2】删除
    sb1.delete(0, 5);//(删除开始位置,结束位置)
    System.out.println(sb1);//输出结果:d
    
    
    // 【3】insert(index,t) 在指定位置index添加t
    sb1.insert(0, "123");
    System.out.println(sb1);//输出结果:123d
    
    // 【4】修改
    sb1.setCharAt(0, 'A');//(index,t) 在指定位置index中改成A
    System.out.println(sb1);//输出结果:A23d
    
    // 【5】setLength
    sb1.setLength(0); // 清空容器内容
    sb1.append("中国"); //重新赋值
    System.out.println(sb1);//输出结果:中国
    
    
    
    StringBuffer sb = new StringBuffer(); //创建一个空的
    sb.append("a");      //增加a进去
    sb.append("b");
    System.out.println(sb.capacity());//输出结果:16(容量)
    
    sb.append("1234567890ABCD");  //增加1234567890ABCD
    sb.append('x');           //增加x
    System.out.println(sb);//输出结果:ab1234567890ABCDx
    System.out.println(sb.capacity());//输出结果:34 (因为里面的东西超过了16个字节,所以扩容了)
    //原理:创建一个新的StringBuffer对象,再把这个对象复制过去
    
    
    // 未来如果确定不再向sb中添加字符,
    // 优化内部的数组到指定的长度
    sb.trimToSize();
    System.out.println(sb.capacity());//输出结果:17
    


}
}

 

转载于:https://www.cnblogs.com/406070989senlin/p/10780599.html

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/35875.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注