java常用类

女爷i 2022-05-28 01:09 245阅读 0赞

### java堆栈基本知识： ###

基本数据类型、局部变量都是存放在栈内存中的，用完就消失。  
new创建的实例化对象及数组，是存放在堆内存中的，用完之后靠垃圾回收机制不定期自动消除。

### 一、字符串类 ###

#### 1、String 类 ####

String类：构造字符串对象   
字符串的字符使用Unicode字符编码，一个字符占两个字节   
底层用char型数组实现

/* * String:代表不可变的字符序列。底层使用char[]存放。 * String 是final的。 */
        @Test
        public void test1(){
            String str1 = "JavaEE";
            String str2 = "JavaEE";
            String str3 = new String("JavaEE");
            String str4 = "JavaEE" + "Android";
            String str5 = "Android";
            String str6 = str1 + str5;
            str5 = str5 + "Handoop";
            String str7 = str6.intern();
            String str8 = "JavaEEAndroid";
            System.out.println(str1 == str2);//true
            System.out.println(str1 == str3);//false
            System.out.println(str1.equals(str3));//true
    
            System.out.println(str4 == str6);//false
            System.out.println(str4.equals(str6));//true
            System.out.println(str7 == str4);//true
            System.out.println(str4 == str8);//true
    
            Person p1 = new Person("AA");
            Person p2 = new Person("AA");
            System.out.println("^_^"+ (p1.name == p2.name));//true
        }
    }
    
    class Person{
        String name;
        Person(String name){
            this.name = name;
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36

![这里写图片描述][SouthEast]

字符串对象操作

*  public int length()
 *  public char charAt(int index):返回在指定index位置的字符。index从0开始
 *  public boolean equals(Object anObject)：比较两个字符串是否相等。相等返回true。否则返回false
 *  public int compareTo(String anotherString)
 *  public int indexOf(String s)：返回s字符串在当前字符串中首次出现的位置。若没有，返回-1
 *  public int indexOf(String s ,int startpoint)：返回s字符串从当前字符串startpoint位置开始的，首次出现的位置。
 *  public int lastIndexOf(String s):返回s字符串最后一次在当前字符串中出现的位置。若无，返回-1
 *  public int lastIndexOf(String s ,int startpoint)
 *  public boolean startsWith(String prefix):判断当前字符串是否以prefix开始。
 *  public boolean endsWith(String suffix)：判断当前字符串是否以suffix结束。
 *  public boolean regionMatches(int firstStart,String other,int otherStart ,int length):判断当前字符串从firstStart开始的子串与另一个字符串other从otherStart开始，length长度的字串是否equals

字符串对象修改

*  public String substring(int startpoint)
 *  public String substring(int start,int end):返回从start开始到end结束的一个左闭右开的子串。start可以从0开始的。
 *  pubic String replace(char oldChar,char newChar)
 *  public String replaceAll(String old,String new)
 *  public String trim()：去除当前字符串中首尾出现的空格，若有多个，就去除多个。
 *  public String concat(String str):连接当前字符串与str
 *  public String\[\] split(String regex)：按照regex将当前字符串拆分，拆分为多个字符串，整体返回值为String\[\]

字符串练习

/* * 1.模拟一个trim方法，去除字符串两端的空格。 2.将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg” 3.获取一个字符串在另一个字符串中出现的次数。比如：获取“ab”在 “abkkcadkabkebfkabkskab”中出现的次数 4.获取两个字符串中最大相同子串。比如：str1 = "abcwerthelloyuiodef";str2 = "cvhellobnm" 5.对字符串中字符进行自然顺序排序。 */
    public class StringDemo { 
        public static void main(String[] args){
    // String str=" abc de ";
            String str=" ";
            String str1=myTrim(str);
            System.out.println("A"+str1+"A");
    
            String str2="abcdefg";
            String str3=reverseString(str2, 2, 5);
            System.out.println(str3);
    
            String str4=reverseString1(str2, 2, 5);
            System.out.println(str4);
    
            String str5="abkkcadkabkebfkabkskab";
            System.out.println(getTimes(str5,"ab"));
    
            List<String> strs=getMaxString("abcdeakajflkahellodf","abcdeqreihello");
            System.out.println(strs);
    
            String str6="aediewfn";
            System.out.println(sort(str6));
        }
    
        //5.对字符串中字符进行自然排序
        public static String sort(String str){
            char[] c=str.toCharArray();
            Arrays.sort(c);
            return new String(c);
        }
    
        //4.获取两个字符串中最大相同子串
        public static List<String> getMaxString(String str1,String str2){
            List<String> strs=new ArrayList<String>();
            String maxStr=(str1.length()>str2.length())?str1:str2;
            String minStr=(str1.length()<str2.length())?str1:str2;
            int len=minStr.length();
            for(int i=0;i<len;i++){
                for(int x=0,y=len-i;y<=len;x++,y++){
                    String str=minStr.substring(x, y);
                    if(maxStr.contains(str)){
                        strs.add(str);
                    }
                }
                if(strs.size()!=0){
                    return strs;
                }
            }
            return null;
        }
    
        //3.获取一个字符串在另一个字符串中出现的次数。判断str2在str1中出现的次数
        public static int getTimes(String str1,String str2){
            int count=0;
            int len;
            int sublength=str2.length();
            while((len=str1.indexOf(str2))!= -1){
                count++;
                str1=str1.substring(len+sublength); 
            }
            return count;
        }
    
        //2.将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
        public static String reverseString1(String str,int start,int end){
            String str1=str.substring(0,start);
            for(int i=end;i>=start;i--){
                str1=str1+str.charAt(i);
            }
            return str1+str.substring(end+1);
        }
    
        public static String reverseString(String str,int start,int end){
            char[] c=str.toCharArray();
            for(int i=start,j=end;i<j;i++,j--){
                char temp=c[i];
                c[i]=c[j];
                c[j]=temp;
            }
            return String.valueOf(c);
        }
    
        //1.模拟一个trim方法，去除自字符串两端的空格。
        public static String myTrim(String str){
            int start=0;
            int end=str.length()-1;
            while(start<end&&str.charAt(start)==' '){
                start++;
            }
            while(start<=end&&str.charAt(end)==' '){
                end--;
            }
            return str.substring(start,end+1);
        }
    
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103

字符串与其他类型数据转化

/* * 1.字符串 与基本数据类型、包装类之间转换 * ①字符串 --->基本数据类型、包装类:调用相应的包装类的parseXxx(String str); * ①基本数据类型、包装类--->字符串:调用字符串的重载的valueOf()方法 * * 2.字符串与字节数组间的转换 * ①字符串---->字节数组:调用字符串的getBytes() * ②字节数组---->字符串：调用字符串的构造器 * * 3.字符串与字符数组间的转换 * ①字符串---->字符数组：调用字符串的toCharArray(); * ②字符数组---->字符串:调用字符串的构造器 */
        @Test
        public void test5(){
            //1.字符串 与基本数据类型、包装类之间转换
            String str1 = "123";
            int i = Integer.parseInt(str1);
            System.out.println(i);
            String str2 = i + "";
            str2 = String.valueOf(i);
            System.out.println(str2);
            System.out.println();
            //2.字符串与字节数组间的转换
            String str = "abcd123";
            byte[] b = str.getBytes();
            for(int j = 0;j < b.length;j++){
                System.out.println((char)b[j]);
            }
            String str3 = new String(b);
            System.out.println(str3);
            System.out.println();
            //3.字符串与字符数组间的转换
            String str4 = "abc123中国人";
            char[] c = str4.toCharArray();
            for(int j = 0;j < c.length;j++){
                System.out.println(c[j]);
            }
            String str5 = new String(c);
            System.out.println(str5);
        }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41

#### 2、StringBuffer 类 ####

java.lang.StringBuffer代表可变的字符序列，可对字符串内容进行增删，而String每次有新的字符串就会在字符串常量池里新建一个字符串。   
StringBuffer是一个容器。   
线程安全

StringBuffer类有三个构造方法：   
1．StringBuffer()初始容量为16的字符串缓冲区   
2．StringBuffer(int size)构造指定容量的字符串缓冲区   
3．StringBuffer(String str)将内容初始化为指定字符串内容

![这里写图片描述][SouthEast 1]   
![这里写图片描述][SouthEast 2]

大部分方法同String，多出的方法如下：   
添加：sb.append(“abc”).append(“123”).append(true);   
插入：insert(int index,String str)   
翻转：reverse( ) 翻转此StringBuffer   
查：charAt(int n)//String 也有   
修改：setCharAt(int index,char ch)   
删除：delete(int i,int j)   
长度：length() //String也有

#### 3、StringBuilder 类 ####

可变的字符序列   
是JDK5.0 新加入的   
线程不安全，但效率高于StringBuffer   
效率：StringBuilder>StringBuffer>String

### 二、日期类 ###

#### 1、java.lang.System类 ####

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。此方法适于计算时间差。

计算世界时间的主要标准有：   
UTC(Universal Time Coordinated)   
GMT(Greenwich Mean Time)   
CST(Central Standard Time)

#### 2、java.util.Date类 ####

表示特定的瞬间，精确到毫秒   
java.sql.Date类是其子类

构造方法：   
\- Date( )使用Date类的无参数构造方法创建的对象可以获取本地当前时间。   
\- Date(long date)

常用方法：   
\- getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。   
\- toString():把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)，zzz是时间标准。

#### 2、java.text.SimpleDateFormat类 ####

易于国际化，默认的模式和语言环境创建对象   
格式化：日期->文本 使用SimpleDateFormat的format方法   
解析：文本->日期 使用SimpleDateFormat的parse方法

@Test
        public void test() throws ParseException{
            //格式化1 按默认的格式
            SimpleDateFormat sdf=new SimpleDateFormat();
            String date=sdf.format(new Date());
            System.out.println(date);//17-2-23 下午8:38
            //格式化2 按指定的格式
            SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            date=sdf1.format(new Date());
            System.out.println(date);//2017-02-23 08:41:08
    
            //解析
            Date date1=sdf.parse("17-2-23 下午8:38");
            System.out.println(date1);//Thu Feb 23 20:38:00 CST 2017
            date1=sdf1.parse("2017-02-23 08:41:08");
            System.out.println(date1);//Thu Feb 23 08:41:08 CST 2017
        }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17

指定的日期格式可以为：   
![这里写图片描述][SouthEast 3]

例题：

/* * "三天打渔两天晒网" 从1990-01-01开始后的某天 xxxx-xx-xx 是在打渔还是在晒网？ */
    
        //返回date1与date2之间的天数
        public int getDays(String date1,String date2) throws ParseException{
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
            Date d1=sdf.parse(date1);
            Date d2=sdf.parse(date2);
            long milliTime=d2.getTime()-d1.getTime();
            return (int)milliTime/1000/3600/24+1;
        }
    
        @Test
        public void test1() throws ParseException{
            String str1="1990-01-01";
            String str2="2014-05-12";
            int dates=getDays(str1, str2);
            if(dates%5==0||dates%5==4){
                System.out.println("晒网");
            }else{
                System.out.println("打渔");
            }
        }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24

#### 3.java.util.Calendar(日历)类 ####

Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。   
获取Calendar实例的方法   
\- 使用Calendar.getInstance()方法   
\- 调用它的子类GregorianCalendar的构造器。

一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY\_OF\_WEEK、HOUR\_OF\_DAY 、MINUTE、SECOND   
\- public void set(int field,int value)   
\- public void add(int field,int amount)   
\- public final Date getTime()   
\- public final void setTime(Date date)

@Test
        public void test4(){
            Calendar c=Calendar.getInstance();//获取当前日历
            int day=c.get(Calendar.DAY_OF_MONTH);//获取是这个月的第几天
            System.out.println(day);
    
            c.add(Calendar.DAY_OF_MONTH, 2);//往后加两天，-2为往前推两天
            day=c.get(Calendar.DAY_OF_MONTH);//获取是这个月的第几天
            System.out.println(day);
    
            c.set(Calendar.DAY_OF_MONTH, 1);//设置日历为当月的第一天
            Date d=c.getTime();
            System.out.println(d);
        }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14

### 三、Math类 ###

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。   
abs 绝对值   
acos,asin,atan,cos,sin,tan 三角函数   
sqrt 平方根   
pow(double a,doble b) a的b次幂   
log 自然对数   
exp e为底指数   
max(double a,double b)   
min(double a,double b)   
random() 返回0.0到1.0的随机数   
long round(double a) double型数据a转换为long型（四舍五入）   
toDegrees(double angrad) 弧度—>角度   
toRadians(double angdeg) 角度—>弧度

### 四、BigInteger类 ###

Integer类作为int的包装类，能存储的最大整型值为2^31−1，BigInteger类的数字范围较Integer类的数字范围要大得多，可以支持任意精度的整数。   
构造器：   
BigInteger(String val)   
常用方法：   
public BigInteger abs()   
public BigInteger add(BigInteger val)   
public BigInteger subtract(BigInteger val)   
public BigInteger multiply(BigInteger val)   
public BigInteger divide(BigInteger val)   
public BigInteger remainder(BigInteger val)   
public BigInteger pow(int exponent)   
public BigInteger\[\] divideAndRemainder(BigInteger val)

### 四、BigDecimal类 ###

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。BigDecimal类支持任何精度的定点数。   
构造器：   
public BigDecimal(double val)   
public BigDecimal(String val)   
常用方法：   
public BigDecimal add(BigDecimal augend)   
public BigDecimal subtract(BigDecimal subtrahend)   
public BigDecimal multiply(BigDecimal multiplicand)   
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

public void testBigInteger(){
    BigInteger bi = new BigInteger("12433241123");
    BigDecimal bd = new BigDecimal("12435.351");
    BigDecimal bd2 = new BigDecimal("11");
    System.out.println(bi);
    //System.out.println(bd.divide(bd2));
    System.out.println(bd.divide(bd2,BigDecimal.ROUND_HALF_UP));
    System.out.println(bd.divide(bd2,15,BigDecimal.ROUND_HALF_UP));
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9

习题：   
String s = new String(“xyz”);创建了几个String Object   
答：两个，一个字符对象，一个字符对象引用对象

Math.round(11.5)等于多少? Math.round(-11.5)等于多少   
答: Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回与参数最接近的长整数，参数加1/2后求其floor

是否可以继承String类   
答：String类是final类故不可以继承

String与StringBuffer的区别。   
答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

[SouthEast]: /images/20220528/4d344047329b4719a74be1fab31e2337.png
[SouthEast 1]: /images/20220528/b57f839071b74a6fa7740fdced5162d7.png
[SouthEast 2]: /images/20220528/d1bc5619d4ae43dfbf34ca3b7154c444.png
[SouthEast 3]: /images/20220528/8d6f58ce128a490f9d29e9a2ac82431d.png