java包装类等其他类

包装类(wrapper)

八大基本数据类型的封装类:

  1. boolean—>Boolean
  2. char—>Character
  3. byte–>Byte
  4. int–>Integer
  5. long–>Long
  6. float–>Float
  7. double–>Double
  8. short–>Short

装箱和拆箱:

jdk5以前的都是手动装箱和拆箱。jdk5以后是自动装箱和拆箱。

自动装箱底层调用的是valueOf方法。比如,Integer.valueof(),其他包装类的用法类似。

Integer包装类:

public class Wrapper01 {
   public static void main(String[] args) {
      Integer integer = new Integer(1);//通过new出来的都是新的对象。
      Integer integer1 = new Integer(1);
      System.out.println(integer==integer1);//false
      Integer i=1;//自动调用valueOf方法。
      Integer j=1;//自动调用valueOf方法。
      System.out.println(i==j);//true
      Integer i1=128;
      Integer j2=128;
      System.out.println(i1==j2);//false
   }
}

//valueOf方法。
//This method will always cache values in the range -128 to 127,
public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

通过底层代码可知,在通过valueOf方法创建对象时,如果数值在-128-127之间,便返回IntegerCache.cache中已经存在的对象引用;否则创建一个新的对象。

Integer i2=127;
      int j3=127;
      System.out.println(i2==j3);//true.

只要有基本数据类型,则判断的是数值是否相等。

String

  1. String对用于保存字符串,也就是一组字符序列。

  2. String类有很多构造器,例如:

    String s=new String(String original);
    String s1=new String(char[] a);
    String s2=new String(char[] a,int starIndex,int count);
    String s3=new String(byte[] b);
    
    
  3. String实现了接口Serializable,可以在网络传输。

  4. String是final类,不能被其他类继承。

  5. String有属性private final char value[] ,用于存放字符串内容。

  6. value是一个final类型,不可以修改,即: 地址是不能修改的,但是单个字符内容是可以变化的。

两种创建String的区别:

方式一:String n1=“zhang”;

方式二:String n2=new String(“zhang”);

第一种方式先从常量池中看是否有"zhang"的数据空间,如果有直接指向,如果没有则要创建然后指向。n1最终指向的是常量池的地址。

第二种方式先在堆中创建空间,指向常量池的的zhang空间,如果常量池没有,则重新创建,如果有直接通过value指向,最终指向的是堆中的空间。

java包装类等其他类

例题:

      String n3="zhang";//指向常量池。
      String n4 = new String("zhang");//指向堆中对象。
      System.out.println(n3.equals(n4));//true.
      System.out.println(n3==n4);//false。
      System.out.println(n3==n4.intern());//true

注意:b4.intern()方法最终返回的是常量池的地址。

面试题:

String是一个final类,代表不可变的字符序列。

String n1="hello";
n1="hi";
//先后在常量池中创建了"hello"对象和"hi"对象,最终n1指向的是"hi"对象。
String a="hello";
String b="abc";
//先创建一个StringBulider sb=new StringBuilder();
//执行 sb.append("hello"),在执行sb.append("abc")。
//String c=sb.toString(查看底层发现其实toString方法是new了一个新的对象。)
//最后c指向堆中的对象,对象中的value指向常量池中的"helloabc".
String c=a+b; 

注意:String c=a+b;

​ String c=“hello”+“abc”;

两者区别: 前者是变量相加,看的是堆,后者是常量相加,看的是池。

public class StringExercise02 {
   public static void main(String[] args) {
      Test ex = new Test();
      ex.change(ex.str,ex.ch);//调方法会产生一个新栈,当方法调用完毕就被销毁了。
      System.out.print(ex.str+" and"+"\t");
      System.out.print(ex.ch);
   }
}
class Test{
   String str=new String("hsp");
   final char[] ch={'j','a','v','a'};
   public void change(String str,char[] ch){
      str="java";
      ch[0]='h';
   }
}
//hsp and hava

内存分布图如下:

java包装类等其他类

String类的常用方法:

     String s=new String("zhangz");
     System.out.println(s.equalsIgnoreCase("ZHANG"));//大小写。false;
     System.out.println(s.charAt(1));//获取某索引处的字符。h
     System.out.println(s.indexOf("z"));//获取字符在字符串中第一次出现的索引位置。0
     System.out.println(s.lastIndexOf("z"));//获取字符在字符串中最后出现的索引位置。5
     System.out.println(s.substring(1));//截取索引后面的字符:hangz
     System.out.println(s.substring(0,4));//从第0个开始截,截到第三个。zhan
     



    
     String s="zhang";
     System.out.println(s.toUpperCase());//转化成大写。ZHANG
     System.out.println(s.toLowerCase());//转化成小写。zhang
     System.out.println(s.concat("jian").concat("handsome").concat("great"));
//字符串拼接。zhangjianhandsomegreat
     System.out.println(s.replace("zhang","jian"));//替代。jian
     System.out.println("===================");
     String poem="锄禾日当午,汗滴禾下土,谁之盘中餐,粒粒皆辛苦";
     String[] split = poem.split(",");//分割字符串。以","为标准分割。
     for (String s1 : split) {
        System.out.println(s1+"\t");
     }
     String n="\\aaa\\bbb\\ccc\\ddd";
     String[] split1 = n.split("\\\\");//在对字符串进行分割时,如果有特殊字符,需要加入转义字符"\"
     for (String s1 : split1) { 
        System.out.println(s1);
     }\\aaa
       \\bbb
       \\ccc
       \\ddd
     String s1="zhang";
     char[] chars = s1.toCharArray();//转化成字符数组。
     for (char aChar : chars) {
        System.out.println(aChar);
     }
     String n1="zhnge";
     String n2="zhang";
     System.out.println(n1.compareTo(n2));//比较两个字符串的大小,如果长度相同,并且每个字符串都相同,就返回零;如果长度不相同或者相同,在进行比较时,当出现第一个不相同的字符时,ASCII值相减即为结果;如果前面的部分相同,就返回n1.length-n2.length
  
String name="张瑊";
    int age=21;
    double score=99.0;
    char gender='男';
    String format = String.format("我的名字是:%s ,年龄是:%d ,得分是:%.2f ,性别是:%c",           name, age, score, gender);
    //%s,%d,%.2f,%c,这些都称之为占位符,由后面的变量替代,%s表示后面由字符串替代,%d是整数替代,%.2f表示使用小数替代,保留两位小数,并且进行四舍五入。%c使用char类型替代。
    System.out.println(format);

StringBuffer类

StringBuffer的直接父类是AbstractStringBuilder。

StringBuffer实现了Serializable,即对象可以串行化。

在父类中AbstractStringBuilder有属性char[] value,不是final,该value存放的字符串内容存放在栈中。

StringBuffer是一个final类,不能被继承。

例题:

//小数点的前面每三位用逗号隔开。
public static void main(String[] args) {
        String s = "121343455.44";
        StringBuffer stringBuffer = new StringBuffer(s);
        for (int i1 = stringBuffer.lastIndexOf(".") - 3; i1 > 0; i1 -= 3) {
            stringBuffer.insert(i1, ",");
        }
        System.out.println(stringBuffer);
    }

String和StringBuffer对比:

String保存的是字符串常量,里面的值不能修改,每次String的更新实际上就是更该地址,效率比较低。

//private final char[] value 指向常量池。

StringBuffer保存的是字符串变量,里面的值可以修改,每次StringBuffer的更新是内容更新,不用更改地址,效率较高。

//char[] value 指向堆。

String和StringBuffer转换:

 //String转StringBuffer
      String s="zhang";
      //1.使用构造器。
      StringBuffer stringBuffer = new StringBuffer(s);
      //2.使用append方法。
      StringBuffer stringBuffer1 = new StringBuffer().append(s);
 //StringBuffer转String。
      StringBuffer stringBuffer2 = new StringBuffer("张瑊不帅");
      //1.使用toString方法创建。
      String string = stringBuffer2.toString();
      //2.使用构造器。
      String s1 = new String(stringBuffer2);

StringBuffer的常用方法:

 StringBuffer stringBuffer = new StringBuffer("张瑊");
      //添加。
      stringBuffer.append(",");
      stringBuffer.append("超级帅。");
      stringBuffer.append("没错。");
      System.out.println(stringBuffer);
      //删除。删除[0,2)之间的字符。
     stringBuffer.delete(0,2);
      System.out.println(stringBuffer);
      //替换。[0,2)
      stringBuffer.replace(0,2,"陈冠希");
      System.out.println(stringBuffer);
      //查找指定的字串第一次在字符串中出现的索引。如果找不到,就返回-1;
      System.out.println(stringBuffer.indexOf("冠希"));
      //指定位置插入
      System.out.println(stringBuffer.insert(0, "吴彦祖,"));
      //返回长度。
      System.out.println(stringBuffer.length());

   }

StringBuilder类

  1. StringBulider继承了AbstractStringBuilder类。
  2. 实现了Serializable,说明StringBulider对象可以串行化。
  3. StringBuilder是final类,不能被继承。
  4. StringBulider对象字符序列仍然是保存在父类的char[] value 中。
  5. StringBulider因为没有synchronized关键字,因此在单线程的情况下使用。

StringBuffer,StringBuilder和String的比较:

  • StringBuffer和StringBuilder均为可变字符序列,而且方法也一样。
  • String:不可变字符序列,效率低,但是复用率高。
  • StringBuffer:可变字符序列,效率高,线程安全。
  • StringBuilder:可变字符序列,效率高,线程不安全。

Math常用方法:

 int abs = Math.abs(-34);//求绝对值。
      System.out.println(abs);
      double pow = Math.pow(2,4);//幂
      System.out.println(pow);
      double ceil = Math.ceil(-1.89);//向上取整。
      System.out.println(ceil);
      double floor = Math.floor(-4.49);//向下取整。
      System.out.println(floor);
      long round = Math.round(1.2);//四舍五入。
      System.out.println(round);
      double sqrt = Math.sqrt(4);//求开方。
      System.out.println(sqrt);
      for (int i = 0; i < 10; i++) {
         System.out.println((int)(2+Math.random()*6));//求随机数,返回的是[2,8)上的数。
      }
      System.out.println(Math.max(2,3));
      System.out.println(Math.min(2,3));

重点:随机数random()

Arrays类:

Integer[] array={1,22323,4,524,50};
System.out.println(Arrays.toString(array));//显示数组。
Arrays.sort(array);//排序数组。
System.out.println(Arrays.toString(array));//再次输出。
//二分查找数组的某个数的索引,数组必须有序。如果数不存在,则返回的是 //return -(low+1)。  
 Integer[] integer={1,3,4,5,};
int i = Arrays.binarySearch(integer, 1);
      System.out.println("index="+i);
      Integer[] array={1,2,34,324,34};
      Integer[] integers =Arrays.copyOf(array,array.length);//数组复制。
      System.out.println(Arrays.toString(integers));

      Integer[] array={1,2,34,324,34};     
      Arrays.fill(array,10);//数组的填充。
      System.out.println(Arrays.toString(array));
      boolean equals=Arrays.equals(array,integers);//比较两个数组的元素是否一样,是,返回true,否,返回false。
      System.out.println(equals);  


例题:

 public static void main(String[] args) {
      Book[] books = new Book[4];
      books[0]=new Book("红楼梦",100);
      books[1]=new Book("新金瓶梅",90);
      books[2]=new Book("新青年文摘",5);
      books[3]=new Book("java从入门到放弃",300);
      Arrays.sort(books, new Comparator<Book>() {
         @Override
          //重写compare方法,如果想改变排序方式直接修改return的值。
         public int compare(Book o1, Book o2) {
            int priceVal= o2.getPrice()-o1.getPrice();
            if(priceVal>0){
               return 1;
            }else if(priceVal<0){
               return -1;
            }else {
               return 0;
            }
         }
      });
      System.out.println(Arrays.toString(books));
     
      System.out.println("=====================");

      Arrays.sort(books, new Comparator<Book>() {
         @Override
         public int compare(Book o1, Book o2) {
            return o1.getName().length()-o2.getName().length();
         }
      });
      for (int i = 0; i <books.length ; i++) {
         System.out.println(books[i].toString());
      }

   }
}
class Book{
   public String getName() {
      return name;
   }

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

   public int getPrice() {
      return price;
   }

   public void setPrice(int price) {
      this.price = price;
   }

   private String name;
   private int price;

   @Override
   public String toString() {
      return "书名为:"+ name + '\'' +
              ", 价格为:" + price ;
   }

   public Book(String name, int price) {
      this.name = name;
      this.price = price;
   }
}

System类:

      long l = System.currentTimeMillis();//当前时间
      Integer[] integers={1,2,4,5};
      Integer[] integers1 = new Integer[3];
      //原数组从第一个元素,新数组第一个元素,复制3个
      System.arraycopy(integers,0,integers1,0,3);
      System.out.println(Arrays.toString(integers1));

BigInteger 类

当数据较大时,用BigInteger进行计算。

      
      BigInteger bigInteger = new BigInteger("200000000000"); 
      BigInteger bigInteger1 = new BigInteger("100000000000");
      //相加
      BigInteger add = bigInteger.add(bigInteger1);
      System.out.println(add);
      //相减
      BigInteger subtract = bigInteger.subtract(bigInteger1);
      System.out.println(subtract);
      //相除
      BigInteger divide = bigInteger.divide(bigInteger1);
      System.out.println(divide);
      //相乘。
      BigInteger multiply = bigInteger.multiply(bigInteger1);
      System.out.println(multiply);

BigDecimal类

当小数数据较大时,用BigDecimal类,

 BigDecimal bigDecimal = new         BigDecimal("1.2222222222222222222222222");
      BigDecimal bigDecimal1 = new BigDecimal("7");
      //相加
      System.out.println(bigDecimal.add(bigDecimal1));
      //相减
      System.out.println(bigDecimal.subtract(bigDecimal1));
      //相乘
      System.out.println(bigDecimal.multiply(bigDecimal1));
      //相除。如果无限循环,则在方法里面写BigDeciaml.ROUND_CEILING,即保留除数的位数。
System.out.println(bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_CEILING));

Date类(第一代日期类)

 Date date = new Date();
      System.out.println(date);
      //创建simpleDateFormat对象,可以指定相应的格式,不能乱写。
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");
      String format = simpleDateFormat.format(date);
      System.out.println(format);//2021年10月29日 星期五 16:18:03
      System.out.println("=================");
      //将字符串转化成日期。
      //得到的date仍然是国外的形式,需要转化输出。
      //如果simpleDateFormat的格式和String的格式不一样,需要抛转换异常。
      String s="2024年10月29日 星期五 16:14:54";
      Date parse = simpleDateFormat.parse(s);
      System.out.println(simpleDateFormat.format(parse));
      System.out.println("================");
      //通过指定的毫秒数得到时间
      Date date1 = new Date(123456);
     System.out.println(simpleDateFormat.format(date1));//1970年01月01日 星期四 08:02:03
   }

Calendar 类(第二代日期类)

Calendar类是一个抽象类,并且构造器时private因此要调用getInstance方法获取实例。

Calendar类没有提供对应的格式化,需要程序员自己写格式化。

  Calendar instance = Calendar.getInstance();
//获取年份
      System.out.println(instance.get(Calendar.YEAR));
//获取月份+1
      System.out.println(instance.get(Calendar.MONTH)+1);
//获取第几天。
      System.out.println(instance.get(Calendar.DAY_OF_MONTH));
//获取小时数。
      System.out.println(instance.get(Calendar.HOUR));
//获取分钟数。
       System.out.println(instance.get(Calendar.MINUTE));
//自己写日期格式:
System.out.println(instance.get(Calendar.YEAR)+"-"+(instance.get(Calendar.MONTH)+1)+"-"+instance.get(Calendar.DAY_OF_MONTH)+"\t"+instance.get(Calendar.HOUR_OF_DAY)+":"+instance.get(Calendar.MINUTE)+":"+instance.get(Calendar.SECOND));//2021-10-30	13:1:18

(常用)LocalDateTime类(第三代日期类)

LocalDateTime now = LocalDateTime.now();
      System.out.println(now);//获取当前日期。
      DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 E HH:mm:ss");//格式日期。
      String format = dateTimeFormatter.format(now);
      System.out.println(format);
      //一年后的时间。
       LocalDateTime localDateTime = now.plusYears(1);
     //一年前的时间。
      LocalDateTime localDateTime1 = now.minusYears(1);
      System.out.println("一年前:"+dateTimeFormatter.format(localDateTime1));
      System.out.println("一年后:"+dateTimeFormatter.format(localDateTime));

习题:

将字符串中指定部分进行反转。

 public static void main(String[] args) {
        String s = "abcdef";
        System.out.println(reverse(s, 1, 4));//aedcbf 

    }

    public static String reverse(String s, int start, int end) {
        if(!(s!=null&&start>=0start<end&&end>start&&end<s.length())){
            throw new ArrayIndexOutOfBoundsException("参数不正确。");
        }
        char[] chars = s.toCharArray();
        char temp;
        for (int i = start, j = end; i < j; i++, j--) {
            temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
        return new String(chars);
    }

上一篇:结对编程项目总结


下一篇:Java基础三