Java常用类

最新推荐文章于 2024-09-02 17:31:14 发布

秋予暮

最新推荐文章于 2024-09-02 17:31:14 发布

阅读量173

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_41439534/article/details/90149969

版权

Java 专栏收录该内容

44 篇文章 0 订阅

订阅专栏

1.String类

在以前的学习过程中我们都在学习对象基本特征、对象的使用以及对象的关系。接下来我们开始使用对象做事情，那么在使用对象做事情之前，我们要学习一些API中提供的常用类。首先来学习API中的String这个类。
String类的特点
查阅API中的String类的描述，String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
继续查阅API发现说字符串是常量；它们的值在创建之后不能更改，这是什么意思呢？其实就是说一旦这个字符串确定了，那么就会在字符串的常量池中生成这个字符串。
//演示字符串是常量
String str = “HE”;
str = “西安”;
当这两句话执行完之后，在字符串常量池中有两个字符串，str引用先指向"HE"这个字符串，然后紧接着str引用"西安"。那么"HE"就没有引用在指向它了。
继续阅读API发现，因为 String 对象是不可变的，所以可以共享，这又是什么意思呢？其实就是说由于字符串一旦生成，在常量池中是不可变的，那么不管有多少个引用，只要他们的引用的字符串相同，即就是这些引用指向同一片内存区域。
//演示字符串可以共享
String str1 = “itcast”;
String str2 = “itcast”;
System.out.println(str1==str2);
输出的结果为true，就说明str1的引用和str2的引用指向的同一片内存区域。

继续查API发现，字符串有大量的重载的构造函数。通过String类的构造函数可以知道，将字节数组或者字符转成字符串。
String s3 = “abc”;
String s4 = new String(“abc”);
System.out.println(s3==s4);//false
//因为String复写了equals方法，建立字符串自己的判断相同的依据。通过
字符串对象中的内容来判断的。
System.out.println(s3.equals(s4));//true,
s3和s4有什么不同呢？
s3创建，在内存中只有一个对象。这个对象在字符串常量池中
s4创建，在内存中有两个对象。一个new的对象在堆中，一个字符串本身对
象，在字符串常量池中。
String类中方法的查找
String类中有很多的常用的方法，我们在学习一个类的时候，不要盲目的把所有的方法尝试去使用一遍，这时我们应该根据这个对象的特点分析这个对象应该具备那些功能，这样大家应用起来更方便。
字符串是一个对象，那么它的方法必然是围绕操作这个对象的数据而定义
的。我们想想字符串中有哪些功能呢？
1. 有多少个字符?
int length()
String str = “abada”;
int len = str.length();
System.out.println(“len=”+len);
2. 字符的位置
int indexOf(ch,fromIndex);
int index = str.indexOf(‘a’);//获取的是a字符第一次出现的位置。
System.out.println(“index=”+index);
int index1 = str.indexOf(‘a’,index+1);//第二个a字母出现的位置
System.out.println(“index1=”+index1);
str = “sdfghjkl;wertyuiop[sdfghjkla;”;
int index3 = str.lastIndexOf(‘m’);//如果要找的字符不存在，-1
System.out.println(“index3=”+index3);
3. 获取指定位置上的字符。
char charAt(int)
str = “itcast”;
char ch = str.charAt(3);//不存在角标会发生
StringIndexOutOfBoundsException
System.out.println(“ch=”+ch);
4. 获取部分字符串。
String substring(int start,int end);
String s = str.substring(2, 4);//包含头，不包含尾。
System.out.println(“s=”+s);
String类中方法查找练习
前面给大家简单介绍了几个字符串中常用的方法，这个过程中主要让大家学会如何去查阅API，如何找到自己想用的方法。接下来我们来练习下字符串。
String方法查找练习。
1. 字符串是否以指定字符串开头。结尾同理。
boolean startsWith(string)
boolean endsWith(string)
String str = “StringDemo.java”;
boolean b1 = str.startsWith(“Demo”);//false
2. 字符串中是否包含另一个字符串。
boolean contains(string);
int indexOf(string)//如果返回-1，表示不存在。
boolean b2 = str.contains(“Demo”);
3. 字符串中另一个字符串出现的位置。
int indexOf(string)
4. 将字符串中指定的字符串替换成另一个字符串。
String replace(oldstring , newstring)
String s = str.replace(“haha”, “Test”);//没有被替换内容时，结果是原串。
System.out.println(“s=”+s);
5. 将字符串转成一个字符数组。或者字节数组。
toCharArray()
getBytes()
char[] chs = str.toCharArray();
byte[] bytes = str.getBytes();
6. 将字母字符串转成大写的字母字符串。
toUpperCase()
toLowerCase();
String upperString = str.toUpperCase();
7.将字符串按照指定的方式分解成多个字符串, "lisi,wangwu,zhaoliu"获取
三个姓名。
String[] split(string);
str = “lisi,wangwu,zhaoliu”;
String[] names = str.split(",");
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
8. 字符串如何比较大小?
int result = “ab”.compareTo(“ab”);
System.out.println(“result:”+result);
Comparable接口介绍
在开发中若需要对象自身具备比较功能，这时这个对象需要实现Comparable接口，建立属于对象自己的比较方式。

public class Person implements Comparable {
   private String name;
   private int age;
 
   //这里省略对应的get和set方法，需要自己在测试时加上
   /**
    * 建立了Person对象判断是否相同的依据。只要是同姓名同年龄就是同一
个人
    * @param obj
    * @return
    */
   @Override
   public boolean equals(Object obj) {
      if(this == obj)
         return true;
    
      if(!(obj instanceof Person)){
         throw new ClassCastException("类型错误");
      }
      Person p = (Person)obj;    
      return this.name.equals(p.name) && this.age == p.age;
   }
   /**
    * 比较年龄大小的方法。
    */
   @Override
   public int compareTo(Object o) {
    
      if(!(o instanceof Person)){
         throw new ClassCastException("类型错误");
      }
    
      Person p = (Person)o;
 
      return this.age - p.age;    
   }
   @Override
   public String toString() {
      return "Person [name=" + name + ", age=" + age + "]";
   }
}

String类练习

1.String练习-字符串数组排序
案例一：字符串数组[“abc”,“nba”,“cctv”,“itcast”]要求从小到大排序。
字符串数组
思路：

曾经玩过int[]排序，选择，冒泡。
字符串排序同理。
for嵌套循环。
循环中进行元素的大小比较，满足条件位置置换

public static void sortString(String[] strs) {
    
      for (int i = 0; i < strs.length -1 ; i++) {
         for (int j = i + 1; j < strs.length; j++) {
         if(strs[i].compareTo(strs[j])>0){ //对象比较用方法。compareTo。
               swap(strs,i,j);
            }
         }
      }
//    Arrays.sort(strs);
}

2.String练习-字符串出现次数
案例二："witcasteritcasttyuiitcastodfghjitcast"有几个itcast
思路：

无非就是在一个字符串中查找另一个字符串。indexOf。
查找到第一次出现的指定字符串后，如何查找第二个呢？
无需在从头开始，只要从第一次出现的位置+要找的字符串的长度的位置开始向后查找下一个第一次出现的位置即可。
当返回的位置是-1时，查找结束。

public static int getKeyCount(String str, String key) {
      //1,定义变量。记录每一次找到的key的位置。
      int index = 0;
      //2,定义变量，记录出现的次数。
      int count = 0;  
      //3,定义循环。只要索引到的位置不是-1，继续查找。
      while((index = str.indexOf(key,index))!=-1){
       
         //每循环一次，就要明确下一次查找的起始位置。
         index = index + key.length();
       
         //每查找一次，count自增。
         count++;
      }
      return count;
   }

3.String练习-按照长度递减取字符串
案例三： "itcast_sh"要求，将该字符串按照长度由长到短打印出来。

public static void printStringByLength(String str) {
      // 1，通过分析，发现是for嵌套循环。
      for (int i = 0; i < str.length(); i++) {
         for (int start = 0, end = str.length() - i; end <= str.length();
start++, end++) {
            //根据start，end截取字符串。
            String temp = str.substring(start, end);
            System.out.println(temp);
         }
      }
}

2.StringBuffer类和StringBuilder类

查阅StringBuffer的API，线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
原来StringBuffer是个字符串的缓冲区，即就是它是一个容器，容器中可以装很多字符。并且能够对其中的字符进行各种操作。
StringBuffer基本使用
StringBuffer的特点：

是一个字符串缓冲区，其实就是一个容器。
长度是可变，任意类型都行。注意：是将任意数据都转成字符串进行存
储。
容器对象提供很多对容器中数据的操作功能，比如：添加，删除，查找，
修改。
所有的数据最终变成一个字符串。

创建一个字符串缓冲区对象。用于存储数据。
StringBuffer sb = new StringBuffer();
添加数据。不断的添加数据后，要对缓冲区的最后的数据进行操作，必须转成字符串才可以。
String str = sb.append(true).append(“hehe”).toString();
sb.append(“haha”); //添加字符串
sb.insert(2, “it”);//在指定位置插入
sb.delete(1, 4);//删除
sb.replace(1, 4, “cast”);
StringBuffer的练习
缓冲区的应用：无论多少数据，什么类型都不重要，只要最终变成字符串就可以使用StringBuffer这个容器
练习：int[] arr = {34,12,89,68};将一个int[]中元素转成字符串格式 [34,12,89,68]

 public static String toString_2(int[] arr) {
      StringBuffer sb = new StringBuffer();  
      sb.append("[");
      for (int i = 0; i < arr.length; i++) {
         if(i!=arr.length-1){
            sb.append(arr[i]+",");
         }else{
            sb.append(arr[i]+"]");
         }
      }   
      return sb.toString();
   }

StringBuffer和StringBuilder区别
查阅API发现还有一个StringBuilder类，它也是字符串缓冲区，它和StringBuffer的区别是什么呢？
阅读StringBuilder的API说明发现，一个可变的字符序列。此类提供一个与
StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

原来StringBuilder是线程不安全的，即就是在对容器操作的时候，不用去判断同步锁的问题，那么效率就高。并且API告诉我们优先采用StringBuilder类。

3.基本数据类型包装类

基本类型包装类概述
基本类型包装类应用场景：通过文本框获取用户输入的数字数据，可是得到的都是字符串。如果想要对字符串中的数字进行运算，必须要将字符串转成数字。
Java中提供了相应的解决的对象。基本数据类型对象包装类：java将基本数据类型值封装成了对象。封装成对象有什么好处？因为可以提供更多的操作基本数值的功能。
8种基本类型：byte Byte short Short int Integer long
对应的包装类：Long float Float double Double boolean Boolean char Character
其中需要注意int对应的是Integer，char对应的Character，其他6个都是基本类型首字母大写即可。
基本数据类型对象包装类特点：用于在基本数据和字符串之间进行转换。
将字符串转成基本类型
parseXXX(String s);其中XXX表示基本类型，参数为可以转成基本类型的字符串，如果字符串无法转成基本类型，将会发生 NumberFormatException
System.out.println(Integer.parseInt(“123”) + 2);
System.out.println(Integer.parseInt(“a1”, 16));// 可以将其他进制转成十
进制。
将基本数值转成字符串有3种方式
1）基本类型直接与””相连接即可； 34+""
2）调用String的valueOf方法； String.valueOf(34);
3）调用包装类中的toString方法； Integer.toString(34);
基本类型和对象转换
基本数值---->包装对象
Integer i = new Integer(4);//使用构造函数函数
Integer ii = new Integer(“4”);//构造函数中可以传递一个数字字符串
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值
int num = i.intValue();
自动装箱拆箱
JDK1.5以后，有了一个包装类的新特性。目的简化书写，自动装箱
Integer i = 4;//自动装箱。Integer i = Integer.valueOf(4);
i = i + 5;//原理;等号右边：将i对象转成基本数值 i.intValue() + 5;//自动
拆箱。加法运算后，再次装箱。
自动装箱细节

Integer a = new Integer(3);
      Integer b = new Integer(3);
     System.out.println(a==b);//false
     System.out.println(a.equals(b));//true
    
      System.out.println("---------------------");
      Integer x = 128;
      Integer y = 128;
      //在jdk1.5自动装箱时，如果数值在byte范围之内，不会新创建对象空间而
是使用原来已有的空间。
      System.out.println(x==y);
   System.out.println(x.equals(y));

基本类型包装类综合练习
练习： “23 9 -4 18 100 7” 要求对这串数字按照从小到大排序，生成一个数
值有序的字符串。
思路：

只有排序会，排序需要数组，数组中就要有元素。
元素在哪里？在字符串里，怎么取出来呢？要获取字符串中的内容，是不是需要String对象。
从字符串获取到数值后存储到一个int数组中。因为要排序。 4，将排完序的数组变成字符串。

public class WrapperTest {
   private static final String SPACE = " ";
   public static void main(String[] args) {
      String numsString = "23 9 -4 18 100 7";
      numsString = sortNumberString(numsString);
     System.out.println("nums=" + numsString);
   }
   public static String sortNumberString(String numsString) {
      // 这个方法好麻烦，这些数值之间的分割符都是 空格。通过空格对字符
串分离，分出来的都是数字内容的字符串。
      // 一个字符串通过分割变成多个字符串。split();
      String[] strs = numsString.split(SPACE);
      //不能直接对字符串进行大小排序，因为 字符串23 比 字符串9要小，是
错误的，必须转成整数值才可以比较。
      // 将字符串数组转成int数组。
      int[] nums = parseIntArray(strs);
      //对数组排序。
      Arrays.sort(nums);
      //将数组转成字符串。
      return toString(nums);
   }
   private static String toString(int[] nums) {
      StringBuilder sb = new StringBuilder();
      for (int i = 0; i < nums.length; i++) {
         if(i!=nums.length-1){
            sb.append(nums[i]+" ");
         }else{
            sb.append(nums[i]);
         }
      }
      return sb.toString();
   }
   // 将字符串数组转成int数组。
   private static int[] parseIntArray(String[] strs) {
      //定义一个int数组。
      int[] arr = new int[strs.length];
      //遍历字符串数组，把元素转成int存储到arr中。
      for (int i = 0; i < strs.length; i++) {
         arr[i] = Integer.parseInt(strs[i]);
      }
      return arr;
   }
}

4.Date类和Calendar类

Date类介绍
在开发中经常会用到时间和日期，前面学习System类时，其currentTimeMillis方法可以返回当前时间的毫秒值，可是这些数据看起来很不清晰，怎么能让这些数据变的很清晰，便于阅读呢？
在查阅System类的currentTimeMillis方法时，其中让我们另请参见Date类，找到这个Date发现，类 Date 表示特定的瞬间，精确到毫秒。继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

//获取当前时间的毫秒值
long time = System.currentTimeMillis();
//创建日期对象，把当前的毫秒值转成日期对象
Date date = new Date(time);
System.out.println(date);//Wed Dec 11 16:42:06 CST 2013
可是将毫秒值转成日期后，输出的格式不利于我们阅读，继续查阅API，Date中有getYear、getMouth等方法，可以他们已经过时，继续往下查阅，看到了toString方法，点开查阅原来是上面打印的date就是默认调用了这个toString方法，并且在这个方法下面还有让我们参见toLocaleString方法，点进去，这个方法又过时了，从 JDK 1.1 开始，由DateFormat.format(Date date) 取代。

既然这个方法被DateFormat.format(Date date) 取代，那么就要去查阅DateFormat类。
DateFormat类介绍
查阅DateFormat类介绍：DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化。
原来这个类可以帮我们完成日期和文本之间的转换。继续阅读API，DateFormat 可帮助进行格式化并解析任何语言环境的日期。对于月、星期，甚至日历格式（阴历和阳历），其代码可完全与语言环境的约定无关。要格式化一个当前语言环境下的日期，可使用某个静态工厂方法: myString = DateFormat.getDateInstance().format(myDate);

//获取日期格式器对象,在获取格式器对象时可以指定风格，风格包括 FULL、LONG、MEDIUM 和 SHORT
DateFormat format = DateFormat.getDateInstance(DateFormat.LONG);
//对日期进行格式化
String str_time = format.format(date);
System.out.println(str_time);//2013年12月11日

Calendar类介绍
我们可以通过Date获取到日期对象，使用DateFormat方法可以把日期进行格式化，可我们想获取当前日期对应的具体的年，具体的月，具体的日，等信息，怎么获取呢？
找到Date继续查阅，其中有getYear等方法，只是这些方法过时了，并且这些方法的描述中告诉我们参加Calendar类。
查阅Calendar类的API描述，发现原来Calendar类是专门用于描述日历的类，它中维护了一个map集合，在这个集合中存放着所有和日期相关的信息。

public class DateDemo {
   public static void main(String[] args) {
       //获取日历对象
       Calendar c = Calendar.getInstance();
       System.out.println(c);//打印出了一个map集合，其中描述日期的所有信息
       //获取年
       int year = c.get(Calendar.YEAR);
       //获取月,月是从0开始计算的
       int mouth = c.get(Calendar.MONTH)+1;
       //获取日
       int day = c.get(Calendar.DAY_OF_MONTH);
       //获取星期，由于老外们把星期日当作一周的第一天，所有星期日 返回对应的数
字为1
       String week = getWeek(c.get(Calendar.DAY_OF_WEEK));
       System.out.println(year+"年"+mouth+"月"+day+"日"+week);
     
   }
   public static String getWeek(int i) {
       if(i<0 || i>7){
          throw new RuntimeException(i+"没有对应的星期");
       }
       String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星
期六"};
       return weeks[i];
   }
}

日期练习
练习1. 将毫秒值转成指定的日期的格式 xxxx年xx月xx日 hh:mm:ss
//1,毫秒值time—>Date
Date date = new Date(time);
//2,通过日期时间格式器对象DateFormat对日期对象进行格式化(日期—>文本
字符串)
DateFormat format =
DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
String str_time = format.format(date);
System.out.println(str_time);

练习2 . "2012-3-17"转成日期对象。
之前有做过，将一个日期对象转成日期文本字符串这个称之为格式化。现在要做的是文本—>日期对象：解析。这些都是DateFormat中的功能。不同日期风格的文本对应不同的格式器。

   public static void main(String[] args) throws ParseException {
       String str_date = "2012年3月17日";
       //日期格式器。DateFormat
       DateFormat dateFormat =
DateFormat.getDateInstance(DateFormat.LONG);
       Date date = dateFormat.parse(str_date);
       System.out.println(date);
       //这种格式在给定的四种风格中不存在。怎么解析呢？只能使用子类
SimpleDateFormat的方法，
       //1，构造函数明确特定风格，2，applyPattern 方法来修改格式模式
       str_date = "2013/3/17 17--13--45";
       DateFormat dateFormat2 = new SimpleDateFormat("yyyy/MM/dd hh--
mm--ss");
       Date date2 = dateFormat2.parse(str_date);
       System.out.println(date2);
}

练习3. "2013-4-25"到"2013年7月29日"到底有多少天？
思路：
1，到底有多少天？相减的过程。
2，字符串也不能相减啊，毫秒值可以相减。
3，怎么获取毫秒值呢？毫秒值–>日期对象，日期对象–>毫秒值。
4，怎么获取日期对象呢？需要将字符串文本–解析–>日期对象。

public class DateTest2 {
   public static void main(String[] args) throws ParseException {
     
       String str_date1 = "2013-4-25";
       String str_date2 = "2013年7月29日";
       //需要定义两个模式。一个解析str_date1,一个解析str_date2。
       int style_1 = DateFormat.MEDIUM;//默认风格。
       int style_2 = DateFormat.LONG;//默认风格。
     
       int days = getDays(str_date1,str_date2,   style_1,style_2);
      System.out.println("days="+days);
   }
   private static int getDays(String str_date1, String str_date2,
          int style_1, int style_2) throws ParseException {
 
       //1，根据给定风格创建格式器对象。
       DateFormat format_1 = DateFormat.getDateInstance(style_1);
       DateFormat format_2 = DateFormat.getDateInstance(style_2);
     
       //2,对文本进行解析。
       Date date_1 = format_1.parse(str_date1);
       Date date_2 = format_2.parse(str_date2);
     
       //3,获取日期对象毫秒值。
       long time_1 = date_1.getTime();
       long time_2 = date_2.getTime();
     
       //4,相减。
       long time = Math.abs(time_1 - time_2);
       int day = (int)(time/1000/60/60/24);
       return day;
   }
}

4. 获取给定年份的2月有多少天？

public class DateTest3 {
   public static void main(String[] args) {
       for (int year = 2000; year <= 2020; year++) {
          show(year);
       }
   }
   public static void show(int year) {
       Calendar c = Calendar.getInstance();//
       // 有获取有设置 set
       c.set(year, 2, 1);
       // 时间是连续的，3月1日的前一天就2月的最后一天，知道2月份的天数。
       c.add(Calendar.DAY_OF_MONTH, -1);
       int year1 = c.get(Calendar.YEAR);
       int month = c.get(Calendar.MONTH) + 1;
       int day = c.get(Calendar.DAY_OF_MONTH);
       String week = getCnWeek(c.get(Calendar.DAY_OF_WEEK));
       // 打印信息中年月日等相关信息都在这里。获取指定字段的值就哦了。
       System.out.println(year1 + "年" + month + "月" + day + "日  " + week);
   }
   public static String getCnWeek(int i) {
       if (i < 0 || i > 7) {
          throw new RuntimeException(i + "没有对应的星期");
       }
       // 定义表。
       String[] weeks = { "", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五",
"星期六" };
       return weeks[i];
   }
}