Java基础-Java常用类

1.1 字符串相关的类

1.1.1 String类与常用方法

• String是一个final类，不可变的字符序列
• String对象的字符内容是存储在一个字符数组value[]中的
• 实现了Serializable接口，字符串支持序列化的
• 实现了Comparable接口，可以比较大小

import org.junit.Test;

/**
 * 1.通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中，字符串常量池不会存储内容相同的字符串
 * 2.通过new+构造器的方式，数据在堆开辟空间后的地址值
 *
 * @author gai
 * @create 2020--12--15
 */
public class StringTest {

    @Test
    public void test1() {
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
//        s1 = "hello";
        System.out.println(s1 == s2);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("******");
        String s3 = "abc";
        s3 += "def";
        System.out.println(s2);
        System.out.println(s3);
        String s4 = "abc";
        String s5 = s4.replace('a', 'b');
        System.out.println(s4);
        System.out.println(s5);
    }

    @Test
    public void test2() {
        String s1 = "javaEE";
        String s2 = "javaEE";
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");
        System.out.println(s1 == s2);//t
        System.out.println(s1 == s3);//f
        System.out.println(s1 == s4);//f
        System.out.println(s3 == s4);//f
    }

    @Test
    public void test3() {
        //常量+常量，在常量池中
        //只有有一个变量，结果就在堆中
        //intern()方法，返回值就在常量池中
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//t
        System.out.println(s3 == s5);//f
        System.out.println(s3 == s6);//f
        System.out.println(s5 == s6);//f
        System.out.println(s5 == s7);//f

        String s8 = s5.intern();
        System.out.println(s3 == s8);//t
    }
}

String常用方法

• int length() 返回字符串长度
• char charAt(int index) 返回某索引处的字符
• boolean isEmpty() 判断是否是空字符
• Sring toLowerCase() 转为小写
• String toUpperCase() 转大写
• String trim() 忽略前后空白，返回字符串的副本
• boolean equals(Object obj) 比较字符串的内容是否相同
• boolean equalslgnoreCase(String anotherString) 与equals相似，忽略大小写
• String concat(String str) 字符串连接，等价于“+”
• int compareTo(String anotherString) 比较两个字符串的大小
• String substring(int beginIndex) 从beginIndex到最后一个子字符串，返回一个新字符串
• String substring(int beginIndex,int endIndex) 从beginIndex到endindex(不含)，返回一个新字符串
• boolean endsWith(String suffix) 此字符串是否以指定的后缀结束
• boolean startsWith(String prefix) 此字符串是否以指定的前缀结束
• boolean startsWith(String prefix,int toffset) 此字符串是否从指定索引开始以指定的前缀结束
• boolean contains(CharSequence s) 当且仅当此字符串包含指定的char序列时，返回true
• int indexOf(String str) 指定子字符串在此字符串第一次出现处的索引
• int indexOf(String str,int fromIndex) 指定子字符串在此字符串第一次出现处的索引，从指定索引开始
• int lastIndexOf(String str) 指定子字符串在此字符串最右处出现处的索引
• int lastIndexOf(String str,int fromIndex) 指定子字符串在此字符串最右处出现处的索引，从指定的索引开始反向
• String replace(char oldChar,char new Char) newChar替换所有oldChar字符
• String replace(CharSequence target,CharSequence replacement)
• String replaceAll(String regex,String replacement) 使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串
• String replaceFirst(String regex,String replacement)
• boolean matches(String regex) 此字符串是否匹配给定的正则表达式
• String[] split(String regex) 给定正则表达式的匹配拆分此字符串
• String[] split(String regex,int limit) 最多不超过limit个，如果超了，剩下的全部都放在最后一个元素中

package string.stringtest;

import org.junit.Test;

/**
 * @author gai
 * @create 2020--12--15
 */
public class StringMethodTest {

    @Test
    public void test1() {
        String s1 = " Hello World ";
        System.out.println(s1.length());
        System.out.println(s1.charAt(1));
//        System.out.println(s1.charAt(10));
//        s1="";
        System.out.println(s1.isEmpty());
        String s2 = s1.toLowerCase();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1.trim());
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));
        System.out.println(s2.concat("java"));
        System.out.println(s1.compareTo(s2));//涉及到字符串排序

        String s7 = "盖盖大大";
        System.out.println(s7.substring(1, 4));//左闭右开
    }

    @Test
    public void test2() {
        String s1 = "helloWorld";
        System.out.println(s1.endsWith("orld"));
        System.out.println(s1.startsWith("ell", 1));
        System.out.println(s1.contains("llo"));

        System.out.println(s1.indexOf("or"));
        System.out.println(s1.indexOf("lo", 7));

        System.out.println(s1.lastIndexOf('o', 5));

        //一个str或不存在，indexOf(str)和lastIndexOf(str)值相同
    }

    @Test
    public void test3() {
        String str1 = "北京北京欢迎你";
        System.out.println(str1.replace("北京", "东京"));

        String tel = "0571-4503428";
        System.out.println(tel.matches("0571-\\d{7,8}"));

        String str = "java|world|java";
        String[] split = str.split("\\|");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

    }
}

字符串–>基本数据类型、包装类
Interger包装类的public static int parseInt(String s):可以将由“数字”字符组成的字符串转换为整型
基本数据类型、包装类–>字符串
调用String类的public String valueOf(int n)可将int转换为字符串
字符数组–>字符串
String类的构造器：String(char[])和String(char[],int offset,int length)分别用字符数组中的全部字符和部分字符创建字符串对象
字符串–>字符数组
public char[] toCharArray() 将字符串中的全部字符存放在一个字符数组中
字节数组–>字符串，解码
String(byte[]) 使用平台的默认字符集解码指定的byte数组，构造一个String
字符串–>字节数组，编码
public byte[] getBytes() 使用默认字符集将String编码为byte序列

@Test
    public void test3() {
        String str1 = "北京北京欢迎你";
        System.out.println(str1.replace("北京", "东京"));

        String tel = "0571-4503428";
        System.out.println(tel.matches("0571-\\d{7,8}"));

        String str = "java|world|java";
        String[] split = str.split("\\|");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

    }

    @Test
    public void test4() throws UnsupportedEncodingException {
        String str = "123";
        int i = Integer.parseInt(str);
        String s = String.valueOf(i);

        String str1 = "abc123";
        char[] chars = str1.toCharArray();
        for (int i1 = 0; i1 < chars.length; i1++) {
            System.out.println(chars[i1]);
        }

        char[] chars1 = new char[]{'h', 'e', 'e'};
        String s1 = new String(chars1);
        System.out.println(s1);

        String s2 = "abc123中国";
        byte[] bytes = s2.getBytes();
        byte[] gbks = s2.getBytes("gbk");
        System.out.println(Arrays.toString(bytes));
        System.out.println(Arrays.toString(gbks));

        String s3 = new String(gbks,"gbk");
        System.out.println(s3);
    }

1.1.2 StringBuffer

• 可变的字符序列，JDK1.0，可以对字符串进行增删，此时不会产生新的对象

• 很多方法与String相同

• 作为参数传递时，方法内部可以改变值

• public StringBuffer(String str) {
  super(str.length() + 16);
  append(str);
  }

• StringBuffer append(xxx)：提供了很多append()方法，用于进行字符串拼接

• StringBuffer delete(int start,int end)：删除指定位置的内容

• StringBuffer replace(int start,int end,String str)：替换

• StringBuffer insert(int offset,xxx)：在指定位置红插入

• StringBuffer reverse()：逆转

笔试题

public class IDEADebug {
    @Test
    public void testStringBuffer() {
        String str = null;
        StringBuilder sb = new StringBuilder();
        sb.append(str);

        System.out.println(sb.length());//4
        System.out.println(sb);//"null"

        StringBuffer stringBuffer = new StringBuffer(str);
        System.out.println(stringBuffer);//

    }
}

1.1.3StringBuilder

• 与StringBuffer非常相似，JDK1.5，可变的字符序列，提供的相关方法也一样
• public int indexOf(String str)
• public String substring(int start,int end)
• public int length()
• public char charAt(int n)
• public void setCharAt(int n,char ch)

String、StringBuffer、StringBuilder的异同
String:不可变的字符序列
StringBuffer:可变的字符序列，线程安全，效率低
StringBuilder:可变的字符序列，线程不安全，效率高，JDK1.5新增
StringBuffer与StringBuilder都是继承抽象类AbstractStringBuilder

public class StringBufferBuilderTest {
    @Test
    public void test1() {
        StringBuffer stringBuffer = new StringBuffer("abc");
        stringBuffer.setCharAt(0, 'm');
        System.out.println(stringBuffer);
        System.out.println(stringBuffer.length());//3
        StringBuffer stringBuffer1 = new StringBuffer();
        System.out.println(stringBuffer1.length());//0

        //扩容问题，默认情况扩容为原来的2倍+2，同时将原来数组复制到新数组，开发建议使用StringBuffer(int capacity)
    }

    @Test
    public void test2() {
        StringBuffer stringBuffer = new StringBuffer("abc");
        stringBuffer.append(1);
        stringBuffer.append('1');
        System.out.println(stringBuffer);
//        stringBuffer.delete(2,4);
//        System.out.println(stringBuffer);
//        stringBuffer.replace(2, 4, "hello");
        stringBuffer.insert(2,false);
        stringBuffer.reverse();
        stringBuffer.substring(1,3);
        System.out.println(stringBuffer);
    }
}

String的算法题

/**
 * 将一个字符串中指定部分进行反转，比如abcdefg转为abfedcg
 *
 * @author gai
 * @create 2020--12--16
 */
public class StringAlgoTest1 {
    //方式一
    public String reverse1(String str, int startIndex, int endIndex) {
        if (str != null) {
            char[] arr = str.toCharArray();
            for (int x = startIndex, y = endIndex; x < y; x++, y--) {
                char temp = arr[x];
                arr[x] = arr[y];
                arr[y] = temp;
            }
            return new String(arr);
        }
        return null;
    }

    //方式二
    public String reverse2(String str, int startIndex, int endIndex) {
        if (str != null) {

            StringBuilder builder = new StringBuilder(str.length());
            //1部分
            builder.append(str.substring(0, startIndex));
            //String reverseString = str.substring(0, startIndex);
            //2部分
            for (int i = endIndex; i >= startIndex; i--) {
                builder.append(str.charAt(i));
            }
//            for (int i = endIndex; i >= startIndex; i--) {
//                reverseString += str.charAt(i);
//            }
            //3部分
            builder.append(str.substring(endIndex + 1));
            return builder.toString();
//            reverseString += str.substring(endIndex + 1);
//            return reverseString;
        }
        return null;
    }
}

/**
 * 获取一个字符串在另一个字符串中出现的次数
 *
 * @author gai
 * @create 2020--12--16
 */
public class StringAlgoTest2 {

    public int getCount(String mainStr, String subStr) {

        int mainLength = mainStr.length();
        int subLength = subStr.length();
        int count = 0;
        int index = 0;
        if (mainLength >= subLength) {

            //方式一
//            while ((index = mainStr.indexOf(subStr)) != -1) {
//                count++;
//                mainStr = mainStr.substring(index + subStr.length());
//            }
            //方式二
            while ((index = mainStr.indexOf(subStr, index)) != -1) {
                count++;
                index += subLength;
            }

            return count;
        } else {
            return 0;
        }
    }

}

/**
 * 获取两个字符串中最大相同字串
 *
 * @author gai
 * @create 2020--12--16
 */
public class StringAlgoTest3 {

    public String getMaxSameString(String str1, String str2) {
        if (str1 != null && str2 != null) {
            String maxStr = (str1.length() >= str2.length()) ? str1 : str2;
            String minStr = (str1.length() < str2.length()) ? str1 : str2;
            int length = minStr.length();

            for (int i = 0; i < length; i++) {
                for (int x = 0, y = length - i; y <= length; x++, y++) {
                    String substring = minStr.substring(x, y);
                    if (maxStr.contains(substring)) {
                        return substring;
                    }
                }
            }

        }
        return null;
    }

}

1.2 JDK8之前的日期时间API

1.2.1 System静态方法

• public static long currenTimeMillis()返回当前时间的时间戳

 @Test
    public void test1(){
        long timeMillis = System.currentTimeMillis();
        System.out.println(timeMillis);
    }

1.2.2 Date类

• Date() 无参构造器获取本地当前时间
• Date(long date)
• getTime() 返回从1970以来此Date对象表示的毫秒数
• toString() 此Date对象转换为String
• java.sql.Date是java.util.Date的子类

@Test
    public void test2() {
        Date date = new Date(1000000L);
        System.out.println(date.toString());
        System.out.println(date.getTime());

        java.sql.Date date1 = new java.sql.Date(423435L);
        System.out.println(date1);

        //将util.Date对象转为sql.Date对象
        Date date2 = new Date();
        java.sql.Date date3 = new java.sql.Date(date2.getTime());
    }

1.2.3 Calendar类

• 是一个抽象类，主要用于完成日期字段之间相互操作的功能
• 使用Calenar实例的方法：使用Calendar.getInstance()方法

@Test
    public void calendarTest() {

        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getClass());

        //常用方法get()
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        //set
        calendar.set(Calendar.DAY_OF_MONTH, 22);
        //add
        calendar.add(Calendar.DAY_OF_MONTH, 3);
        //getTime():日历->Date
        Date date = calendar.getTime();
        System.out.println(date);

        //setTime():Date->日历
        Date date1 = new Date();
        calendar.setTime(date1);
    }

1.2.4 SimpleDateFormat类

• Date大部分废弃，java.text.SimpleDateFormat允许进行格式化：日期->文本、解析：文本->日期
• SimpleDateFormat() 默认模式创建对象
• SimpleDateFormat(String pattern)
• public String format(Date date) 格式化时间对象date
• public Date parse(String source) 给定字符串解析文本，生成一个日期

@Test
    public void testSimpleDateFormat() throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        //格式化日期
        Date date = new Date();
        System.out.println(date);

        System.out.println(simpleDateFormat.format(date));

        //解析
        String str = "2020.12.16 15:44:22";
        System.out.println(simpleDateFormat.parse(str));
    }

1.3 JDK8中新日期时间API

• java.time — 包含值对象的基础包
• java.time.chrono — 提供对不同的日历系统的访问
• java.time.format — 格式化和解析时间和日期
• java.time.temporal — 包括底层框架和扩展特性
• java.time.zone — 包含市区支持的类

1.3.1 LocalDate、LocalTime、LocalDateTime

不可变的对象，提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息

• LocalDate代表IOS格式的日期(yyyy-MM-dd)，可以存储生日、纪念日等日期
• LocalTime表示一个时间，而不是日期
• LocalDateTime用来表示日期和时间的，这是一个最常用的类之一

public class JDK8DateTimeTest {

    //LocalDate、LocalTime、LocalDateTime
    @Test
    public void test1() {
        //now()
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println(localDate);
        System.out.println(localTime);
        System.out.println(localDateTime);
        //of()指定的年月日时分秒，没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
        System.out.println(localDateTime1);

        //get()
        System.out.println(localDateTime.getDayOfMonth());
        System.out.println(localDateTime.getMonthValue());
        System.out.println(localDateTime.getMinute());

        //with()不可变性
        System.out.println(localDateTime.withDayOfMonth(1));
        System.out.println(localDate.withDayOfYear(2));

        System.out.println(localDate.plusYears(2));
        System.out.println(localDate.minusDays(22));
    }
}

1.3.2 Instant

• 时间上的瞬时点，用来记录应用程序中的事件时间戳

@Test
    public void test2(){
        //now()
        Instant instant = Instant.now();
        System.out.println(instant);
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);
        System.out.println(instant.toEpochMilli());
    }

1.3.3 DateTimeFormatter

• 预定义的标志格式
• 本地化相关的格式
• 自定义的格式，重点

//DateTimeFormatter类似于SimpleDateFormat
    @Test
    public void test3() {
        //方式一
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //格式化:日期-->字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(formatter.format(localDateTime));
        //解析：字符串-->日期
        TemporalAccessor parse = formatter.parse("2020-12-18T17:00:49.0930784");
        System.out.println(parse);

        //方式二
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
        System.out.println(dateTimeFormatter.format(localDateTime));

        //方式三
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        System.out.println(dateTimeFormatter1.format(LocalDateTime.now()));
    }

1.3.4 其他类

• ZonId:该类包含了所有的时区信息，一个市区的ID
• ZonedDateTime:日历i系统时区的日期时间
• Clock:使用时区提供对当前即时、日期和时间的访问的时钟
• TemporalAdjuster:时间校正器
• TemporlAdjusters:通过静态方法提供了大量的常用TemporalAdjuster的实现

1.4 Java比较器

1.4.1 Comparable接口：自然排序

public class CompareTest {

    //Comparable接口
    //重写compareTo(obj)

    @Test
    public void test1() {
        Goods[] arr = new Goods[4];
        arr[0] = new Goods("lianxiang", 30);
        arr[1] = new Goods("daier", 90);
        arr[2] = new Goods("xiaomi", 50);
        arr[3] = new Goods("huawei", 70);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

//排序的方式
    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods) {
            Goods goods = (Goods) o;
            if (this.price > goods.price) {
                return 1;
            } else if (this.price < goods.price) {
                return -1;
            } else {
                return this.name.compareTo(goods.name);
            }
        }
        throw new RuntimeException("传入的数据类型不一致");
    }

1.4.2 Comparator接口：定制排序

• 当没有实现Comparable接口，或实现的Comparable不符合当前操作，那可以考虑Comparator对象来排序
• 重写compare(Object o1,Object o2)方法，比较o1和o2的大小
• 可以将Comparator传递给sort方法，从而允许再排序顺序上实现精确控制
• 还可以使用Comparator来控制某些数据结构的顺序，或者为那些没有自然顺序的对象collection提供排序

//Comparator接口的使用
    @Test
    public void test2() {
        String[] arr = new String[]{"AA", "VV", "GG", "DD", "TT"};
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return -o1.compareTo(o2);
            }
        });
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void test3() {
        Goods[] arr = new Goods[4];
        arr[0] = new Goods("lianxiang", 30);
        arr[1] = new Goods("daier", 90);
        arr[2] = new Goods("xiaomi", 50);
        arr[3] = new Goods("huawei", 70);
        Arrays.sort(arr, new Comparator<Goods>() {
            @Override
            public int compare(Goods o1, Goods o2) {
                if (o1.getName().equals(o2.getName())) {
                    return -Double.compare(o1.getPrice(), o2.getPrice());
                } else {
                    return o1.getName().compareTo(o2.getName());
                }
            }
        });
        System.out.println(Arrays.toString(arr));
    }

1.5 System类

• 系统级的很多属性和控制方法都放置再该类的内部，位于java.lang
• 构造器是private的，无法构建该类的对象，内部变量和成员方法都是static的
• System内部包含in、out、err三个成员变量
• 成员方法natice long currentTimeMills();
• void exit(int status);
• void gc();
• String getProperty(String key);

@Test
    public void test1(){
        System.out.println("java的版本"+System.getProperty("java.version"));
        System.out.println("java的home"+System.getProperty("java.home"));
        System.out.println("os"+System.getProperty("os.name"));
        System.out.println("os"+System.getProperty("os.version"));
        System.out.println("user"+System.getProperty("user.name"));
        System.out.println("use"+System.getProperty("user.home"));
        System.out.println("user"+System.getProperty("user.dir"));
    }

1.6 Math类

• 用于科学计算，参数和返回值一般为double
• abs 绝对值
• acos,asin,atan,cos,sin,tan
• sqrt 平方根
• pow()
• log 自然对数
• exp
• max
• min
• random
• round
• toDegrees 弧度->角度
• toRandians 角度->弧度

1.7 BigInteger与BigDecimal

• BigInteger表示不可变的任意精度的整数
• 要求数字精度比较高，用到BigDecimal，支持有符号十进制定点数

 @Test
    public void test2() {
        BigInteger bigInteger = new BigInteger("11111111111111");
        System.out.println(bigInteger);
        BigDecimal bigDecimal = new BigDecimal("1234.112");
        BigDecimal bigDecimal1 = new BigDecimal("11");
        System.out.println(bigDecimal.divide(bigDecimal1,10,BigDecimal.ROUND_HALF_UP));
    }