精华内容
下载资源
问答
  • public int length(); //返回字符串的长度
  • Java基础 - 第四章 - JAVA常用类

    万次阅读 2020-08-28 18:07:16
    JAVA常用类 一、String String:字符串,使用一对""引起来表示。 1.String声明为final的,不可被继承 2.String实现了Serializable接口:表示字符串是支持序列化的。 实现了Comparable接口:表示String可以比较大小 3...

    JAVA常用类

    一、String

    String:字符串,使用一对""引起来表示。
    1.String声明为final的,不可被继承
    2.String实现了Serializable接口:表示字符串是支持序列化的。
            实现了Comparable接口:表示String可以比较大小
    3.String内部定义了final char[] value用于存储字符串数据
    4.String:代表不可变的字符序列。简称:不可变性。
        体现:1.当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值。
             2. 当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
             3. 当调用String的replace()方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
    5.通过字面量的方式(区别于new)给一个字符串赋值,此时的字符串值声明在字符串常量池中。
    6.字符串常量池中是不会存储相同内容的字符串的。
    
        String的实例化方式:
        方式一:通过字面量定义的方式
        方式二:通过new + 构造器的方式
    
         面试题:String s = new String("abc");方式创建对象,在内存中创建了几个对象?
                两个:一个是堆空间中new结构,另一个是char[]对应的常量池中的数据:"abc"
                
                    结论:
                    1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
                    2.只要其中有一个是变量,结果就在堆中。
                    3.如果拼接的结果调用intern()方法,返回值就在常量池中
    

    String常见算法题目

    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--;
            }
            if(start == end){
                return "";
            }
            return str.substring(start, end + 1);
        }
    

    2.将一个字符串进行反转。将字符串中指定部分进行反转。
    比如:将abcdefg 反转为 abfedcg

    方式一
        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 new String(c);
        }
    
    方式二
        public static String reverseString1(String str,int start,int end){
            String str1 = str.substring(0, start);
            for(int i = end;i >= start;i--){
                char c = str.charAt(i);
                str1 += c;
            }
            str1 += str.substring(end + 1);
            return str1;
        }
    
    方式三(使用StringBuilder)
        public static String reverseString3(String str, int start, int end){
                StringBuilder builder = new StringBuilder(str.length());
                builder.append(str.substring(0,start));
                for(int i = end;i >= start;i--){
                    builder.append(str.charAt(i));
                }
                builder.append(str.substring(end + 1));
                return builder.toString();
        }
    

    3.获取一个字符串在另一个字符串中出现的次数。
    比如:获取“ab在abkkcadkabkebfkabkskab”中出现的次数

    方式一
        public static int getTime(String str1,String str2){
            int count = 0;
            int len;
            while((len = str1.indexOf(str2)) != -1){
                count++;
                str1 = str1.substring(len + str2.length());
            }
            return count;
        }
    
    方式二
        public static int getTime2(String str1, String str2){
            int count = 0;
            int i = 0;
            while((i = str1.indexOf(str2, i)) != -1){
                count++;
                i+=str2.length();
            }
            return count;
        }
    

    4.获取两个字符串中最大相同子串。
    比如:str1 = “abcwerthelloyuiodef”; str2 = “cvhellobnm”;
    提示:将短的那个串进行长度依次递减的子串与较长的串比较。

    提示:将短的那个串进行长度依次递减的子串与较长的串比较。
    
    import java.util.*;
    
        public static List<String> getMaxSubString(String str1, String str2){
            String maxStr = (str1.length() > str2.length()) ? str1 : str2;
            String minStr = (str1.length() < str2.length()) ? str1 : str2;
            int len = minStr.length();
            List<String> list = new ArrayList<>();
            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)){
                        list.add(str);
                    }
                }
                if(list.size() != 0){
                    return list;
                }
            }
            return null;
        }
    

    5.对字符串中字符进行自然顺序排序。

    提示:
    1.字符串变成字符数组。
    2.对数组排序,选择,冒泡 Arrays.sort
    3.将排序后的数组变成字符串。
    
    import java.util.*;
    
        public static String sort(String str){
            char[] c = str.toCharArray();
            Arrays.sort(c);
            return new String(c);
        }
    

    二、StringBuffer和StringBuilder

    String、StringBuffer、StringBuilder三者的异同?
    String:不可变的字符序列;底层使用char[]存储
    StringBuffer:可变的字符序列;线程安全的,效率低;底层使用char[]存储
    StringBuilder:可变的字符序列;jdk5.0新增的,线程不安全的,效率高;底层使用char[]存储
    
        源码分析:
        String str = new String();//char[] value = new char[0];
        String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};
    
        StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
        System.out.println(sb1.length());//
        sb1.append('a');//value[0] = 'a';
        sb1.append('b');//value[1] = 'b';
    
        StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];
        
            //问题1. System.out.println(sb2.length());//3
            //问题2. 扩容问题:如果要添加的数据底层数组盛不下了,那就需要扩容底层的数组。
                     默认情况下,扩容为原来容量的2倍 + 2,同时将原有数组中的元素复制到新的数组中。
        
                    指导意义:开发中建议大家使用:StringBuffer(int capacity) 或 StringBuilder(int capacity)
                    
                对比String、StringBuffer、StringBuilder三者的效率:
                从高到低排列:StringBuilder > StringBuffer > String
    

    三、日期与时间

    练习一:字符串"2020-09-08"转换为java.sql.Date

        @Test
        public void testExer() throws ParseException {
            String birth = "2020-09-08";
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf1.parse(birth);
            java.sql.Date birthDate = new java.sql.Date(date.getTime());
            System.out.println(birthDate); //2020-09-08
        }
    

    练习二:“三天打渔两天晒网”

        public static String Test(String startDate, String endDate) throws ParseException {
            SimpleDateFormat startSDF = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat endSDF = new SimpleDateFormat("yyyy-MM-dd");
    
            Date date1 = startSDF.parse(startDate);
            Date date2 = endSDF.parse(endDate);
            
            long time1 = date1.getTime();
            long time2 = date2.getTime();
            
            int day = (int)((((time2 - time1)/1000)/60)/60)/24 + 1;
            int i = day % 5;
            if(i == 1 || i == 2 || i == 3){
                return "打渔";
            }else if (i == 4 || i == 0){
                return "晒网";
            }
            return null;
        }
    

    四、Calendar日历类(抽象类)

        @Test
        public void testCalendar(){
            //1.实例化
            //方式一:创建其子类(GregorianCalendar)的对象
            //方式二:调用其静态方法getInstance()
            Calendar calendar = Calendar.getInstance();
    
            //2.常用方法
            //get()
            int days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
            System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
    
            //set()
            //calendar可变性
            calendar.set(Calendar.DAY_OF_MONTH,22);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
    
            //add()
            calendar.add(Calendar.DAY_OF_MONTH,-3);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
    
            //getTime():日历类---> Date
            Date date = calendar.getTime();
            System.out.println(date);
    
            //setTime():Date ---> 日历类
            Date date1 = new Date();
            calendar.setTime(date1);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
        }
    

    五、JDK8中的日期时间API

    Calendar 并不比 Date 好多少,它们面临的问题是:
        可变性:像日期和时间这样的类应该是不可变的。
        偏移性:Date中的年份是从 1900 开始的,而月份都从0开始。
        格式化:格式化只对Date有用,Calendar则不行。
            此外,它们也不是线程安全的;不能处理闰秒等。
    

    LocalDate、LocalTime、LocalDateTime 的使用

    说明:
        1.LocalDateTime相较于LocalDate、LocalTime,使用频率要高
        2.类似于Calendar
    
        @Test
        public void JDK8DateTimeTest(){
            //now():获取当前的日期、时间、日期+时间
            LocalDate localDate = LocalDate.now();
            LocalTime localTime = LocalTime.now();
            LocalDateTime localDateTime = LocalDateTime.now();
    
            System.out.println(localDate); //2019-07-25
            System.out.println(localTime); //09:23:59.329259400
            System.out.println(localDateTime); //2019-07-25T09:23:59.329259400
    
            //of():设置指定的年、月、日、时、分、秒。没有偏移量
            LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
            System.out.println(localDateTime1); //2020-10-06T13:23:43
    
            //getXxx():获取相关的属性
            System.out.println(localDateTime.getDayOfMonth()); //25
            System.out.println(localDateTime.getDayOfWeek()); //THURSDAY
            System.out.println(localDateTime.getMonth()); //JULY
            System.out.println(localDateTime.getMonthValue()); //7
            System.out.println(localDateTime.getMinute()); //23
    
            //体现不可变性
            //withXxx():设置相关的属性
            LocalDate localDate1 = localDate.withDayOfMonth(22);
            System.out.println(localDate); //2019-07-25
            System.out.println(localDate1); //2019-07-22
            
            LocalDateTime localDateTime2 = localDateTime.withHour(4);
            System.out.println(localDateTime); //2019-07-25T09:23:59.329259400
            System.out.println(localDateTime2); //2019-07-25T04:23:59.329259400
    
            //不可变性
            LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
            System.out.println(localDateTime); //2019-07-25T09:23:59.329259400
            System.out.println(localDateTime3); //2019-10-25T09:23:59.329259400
    
            LocalDateTime localDateTime4 = localDateTime.minusDays(6);
            System.out.println(localDateTime); //2019-07-25T09:23:59.329259400
            System.out.println(localDateTime4); //2019-07-19T09:23:59.329259400
        }
    

    瞬时:Instant

    Instant:时间线上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳。
            Instant的使用类似于 java.util.Date类
    
        @Test
        public void instantTest(){
            //now():获取本初子午线对应的标准时间
            Instant instant = Instant.now();
            System.out.println(instant); //2019-07-25T03:00:05.434260Z
    
            //添加时间的偏移量
            OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
            System.out.println(offsetDateTime); //2019-07-25T11:00:05.434260+08:00
    
            //toEpochMilli():获取自1970年1月1日0时0分0秒(UTC)开始的毫秒数  ---> Date类的getTime()
            long milli = instant.toEpochMilli();
            System.out.println(milli); //1564023605434
    
            //ofEpochMilli():通过给定的毫秒数,获取Instant实例  -->Date(long millis)
            Instant instant1 = Instant.ofEpochMilli(1550475314878L);
            System.out.println(instant1); //2019-02-18T07:35:14.878Z
        }
    

    格式化与解析日期或时间:DateTimeFormatter

    DateTimeFormatter:格式化或解析日期、时间,类似于SimpleDateFormat
    
        @Test
        public void DateTimeFormatterTest(){
    //        方式一:预定义的标准格式。如:ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
            DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
            //格式化:日期-->字符串
            LocalDateTime localDateTime = LocalDateTime.now();
            String str1 = formatter.format(localDateTime);
            System.out.println(localDateTime); //2019-07-25T15:02:40.118440500
            System.out.println(str1); //2019-07-25T15:02:40.1184405
    
            //解析:字符串 -->日期
            TemporalAccessor parse = formatter.parse("2019-02-18T15:42:18.797");
            System.out.println(parse); //{},ISO resolved to 2019-02-18T15:42:18.797
    
    //        方式二:
    //        本地化相关的格式。如:ofLocalizedDateTime()
    //        FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
            DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
            //格式化
            String str2 = formatter1.format(localDateTime);
            System.out.println(str2); //2019/7/25 下午3:02
            
    //      本地化相关的格式。如:ofLocalizedDate()
    //      FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
            DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
            //格式化
            String str3 = formatter2.format(LocalDate.now());
            System.out.println(str3); //2019年7月25日
            
    //       重点: 方式三:自定义的格式。如:ofPattern(“yyyy-MM-dd hh:mm:ss”)
            DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
            //格式化
            String str4 = formatter3.format(LocalDateTime.now());
            System.out.println(str4); //2019-07-25 03:02:40
    
            //解析
            TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
            System.out.println(accessor); //{MinuteOfHour=52, SecondOfMinute=9, MilliOfSecond=0, NanoOfSecond=0, MicroOfSecond=0, HourOfAmPm=3},ISO resolved to 2019-02-18
        }
    

    六、Java比较器

    一、说明:Java中的对象,正常情况下,只能进行比较:==  或  != 。不能使用 > 或 < 的
            但是在开发场景中,我们需要对多个对象进行排序,言外之意,就需要比较对象的大小。
            如何实现?使用两个接口中的任何一个:Comparable 或 Comparator
         
    二、Comparable接口与Comparator的使用的对比:
        Comparable接口的方式一旦一定,保证Comparable接口实现类的对象在任何位置都可以比较大小。
        Comparator接口属于临时性的比较。
    

    方式一:自然排序:java.lang.Comparable

    Comparable接口的使用举例:自然排序
        1.像String、包装类等实现了Comparable接口,重写了compareTo(obj)方法,给出了比较两个对象大小的方式。
        2.像String、包装类重写compareTo()方法以后,进行了从小到大的排列
        3.重写compareTo(obj)的规则:
            如果当前对象this大于形参对象obj,则返回正整数,
            如果当前对象this小于形参对象obj,则返回负整数,
            如果当前对象this等于形参对象obj,则返回零。
        4. 对于自定义类来说,如果需要排序,我们可以让自定义类实现Comparable接口,重写compareTo(obj)方法。
            在compareTo(obj)方法中指明如何排序
    
        @Test
        public void test1(){
            String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
            Arrays.sort(arr);
            System.out.println(Arrays.toString(arr)); //[AA, CC, DD, GG, JJ, KK, MM]
        }
    

    Goods.java

    public class Goods implements Comparable{
        private String name;
        private double price;
    
        public Goods() {
        }
    
        public Goods(String name, double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Goods{" + "name='" + name + '\'' + ", price=" + price + '}';
        }
    
        //指明商品比较大小的方式:按照价格从低到高排序,再按照产品名称从高到低排序
        @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);
                }
                //方式二:
                //return Double.compare(this.price,goods.price);
            }
            throw new RuntimeException("传入的数据类型不一致!");
        }
    }
    
        @Test
        public void test2(){
            Goods[] arr = new Goods[5];
            arr[0] = new Goods("lenovoMouse",34);
            arr[1] = new Goods("dellMouse",43);
            arr[2] = new Goods("xiaomiMouse",12);
            arr[3] = new Goods("huaweiMouse",65);
            arr[4] = new Goods("microsoftMouse",43);
            Arrays.sort(arr);
            System.out.println(Arrays.toString(arr));
            //[Goods{name='xiaomiMouse', price=12.0}, Goods{name='lenovoMouse', price=34.0}, Goods{name='microsoftMouse', price=43.0}, Goods{name='dellMouse', price=43.0}, Goods{name='huaweiMouse', price=65.0}]
        }
    

    方式二:定制排序:java.util.Comparator

    Comparator接口的使用:定制排序
    1.背景:
        当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码,
        或者实现了java.lang.Comparable接口的排序规则不适合当前的操作,
        那么可以考虑使用 Comparator 的对象来排序
    2.重写compare(Object o1,Object o2)方法,比较o1和o2的大小:
        如果方法返回正整数,则表示o1大于o2;
        如果返回0,表示相等;
        返回负整数,表示o1小于o2。
    
        @Test
        public void test3(){
            String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
            Arrays.sort(arr,new Comparator(){
    
                //按照字符串从大到小的顺序排列
                @Override
                public int compare(Object o1, Object o2) {
                    if(o1 instanceof String && o2 instanceof  String){
                        String s1 = (String) o1;
                        String s2 = (String) o2;
                        return -s1.compareTo(s2);
                    }
                    throw new RuntimeException("输入的数据类型不一致");
                }
            });
            System.out.println(Arrays.toString(arr)); //[MM, KK, JJ, GG, DD, CC, AA]
        }
    
        @Test
        public void test4(){
            Goods[] arr = new Goods[6];
            arr[0] = new Goods("lenovoMouse",34);
            arr[1] = new Goods("dellMouse",43);
            arr[2] = new Goods("xiaomiMouse",12);
            arr[3] = new Goods("huaweiMouse",65);
            arr[4] = new Goods("huaweiMouse",224);
            arr[5] = new Goods("microsoftMouse",43);
    
            Arrays.sort(arr, new Comparator() {
                //指明商品比较大小的方式:按照产品名称从低到高排序,再按照价格从高到低排序
                @Override
                public int compare(Object o1, Object o2) {
                    if(o1 instanceof Goods && o2 instanceof Goods){
                        Goods g1 = (Goods)o1;
                        Goods g2 = (Goods)o2;
                        if(g1.getName().equals(g2.getName())){
                            return -Double.compare(g1.getPrice(),g2.getPrice());
                        }else{
                            return g1.getName().compareTo(g2.getName());
                        }
                    }
                    throw new RuntimeException("输入的数据类型不一致");
                }
            });
            System.out.println(Arrays.toString(arr));
            //[Goods{name='dellMouse', price=43.0}, Goods{name='huaweiMouse', price=224.0}, Goods{name='huaweiMouse', price=65.0}, Goods{name='lenovoMouse', price=34.0}, Goods{name='microsoftMouse', price=43.0}, Goods{name='xiaomiMouse', price=12.0}]
        }
    

    七、其他常用类

    1.System

    2.Math

    3.BigInteger 和 BigDecimal

    展开全文
  • Java常用类之String类练习

    千次阅读 2017-04-30 21:10:14
    Java常用类之String类练习

    1.编程. 已知字符串:”this is a test of java”.
    按要求执行以下操作:
    (1) 统计该字符串中字母s出现的次数
    (2) 取出子字符串”test”
    (3) 将本字符串复制到一个字符数组Char[] str中.
    (4) 将字符串中每个单词的第一个字母变成大写, 输出到控制台。
    (5) 用两种方式实现该字符串的倒叙输出。(用StringBuffer和for循环方式分别实现)
    (6) 将本字符串转换成一个字符串数组,要求每个数组元素都是一个有意义的额英文单词,并输出到控制台

    代码:

    package day11Homework;
    
    import java.util.Arrays;
    
    public class Test1 {
        public static void main(String[] args){
            String string="this is a test of java";
    
    //     (1) 统计该字符串中字母s出现的次数
            //first
            char[] c=string.toCharArray();
            int count=0;
            for (char d : c) {
                if(d=='s'){
                    count++;
                }
            }
            System.out.println("s出现的次数"+count);
            //second
            String[] strs1=string.split("s");
            int count2=0;
            count2=strs1.length-1;
            System.out.println("s出现的次数"+count2);
            //third
    
    //     (2) 取出子字符串"test"
            System.out.println("截取test:"+string.subSequence(string.indexOf("t",1), string.lastIndexOf("t")+1));
    //     (3) 将本字符串复制到一个字符数组Char[] str中.
            char[] c2=string.toCharArray();
    //     (4) 将字符串中每个单词的第一个字母变成大写, 输出到控制台。
            String[] strs2=string.split(" ");
            for(int i=0;i<=strs2.length-1;i++){
                //方法一:
                //strs2[i]=strs2[i].replaceFirst(String.valueOf(strs2[i].charAt(0)),String.valueOf(strs2[i].charAt(0)).toUpperCase());
                //方法二:
                strs2[i]=Character.toUpperCase(strs2[i].charAt(0))+strs2[i].substring(1);
            }
            System.out.println(Arrays.toString(strs2));
    //     (5) 用两种方式实现该字符串的倒叙输出。(用StringBuffer和for循环方式分别实现)
            StringBuffer stringBuffer=new StringBuffer("this is a test of java");
            System.out.println(stringBuffer.reverse());
            //for
            for(int i=string.length()-1;i>=0;i--){
                System.out.print(string.charAt(i));
            }
            System.out.println();
    //     (6) 将本字符串转换成一个字符串数组,要求每个数组元素都是一个有意义的英文单词,并输出到控制台
            String[] strs3=string.split(" ");
            System.out.println(Arrays.toString(strs3));
        }
    }
    

    运行结果:
    这里写图片描述

    2 .如下字符串:
    01#张三#20*02#李四#18*03#王五#22*04#赵六#20*05#田七#21

    分割出每个人的信息,样式如下:
    *01 张三 20
    *02 李四 18
    *…..

    *创建Student类,属性:学号 姓名 年龄
    1将这些Student对象放进数组中
    2.查询里面有没有叫田七的学生如果存在则打印学生的具体信息(封装成方法,键盘输入姓名)
    3.计算所有学生的平均年龄,最大年龄,最小年龄
    4.如果存在名字叫张三的将名字改为张兵

    代码:

    学生类

    
    public class Student {
        private String xueHao;
        private String name;
        private int age;
    
        public String getXueHao() {
            return xueHao;
        }
        public void setXueHao(String xueHao) {
            this.xueHao = xueHao;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    
        public Student() {}
    
        public Student(String xueHao,String name,int age){
            this.xueHao=xueHao;
            this.name=name;
            this.age=age;
        }
    }
    

    测试类:

    import java.util.*;
    public class Test3 {
        public static void main(String[] args){
            Scanner input=new Scanner(System.in);
            String str="01#张三#20*02#李四#18*03#王五#22*04#赵六#20*05#田七#21";
            String[] strs=str.split("[#*]");
            System.out.println("1.按要求打印如下:");
            for(int i=0;i<strs.length;i+=3){
                System.out.print(strs[i]+" "+strs[i+1]+" "+strs[i+2]);
                System.out.println();
            }
    
            //建立学生数组
            Student[] arr=new Student[strs.length/3];
            int count=0;
            for(int i=0;i<arr.length;i++){
                arr[i]=new Student(strs[count],strs[count+1],Integer.parseInt(strs[count+2]));
                count+=3;
            }
            System.out.println("2.查询里面有没有叫田七的学生如果存在则打印学生的具体信息:");
            System.out.println("请输入学生姓名:");
            String name=input.next();
    
            for(int i=0;i<arr.length;i++){
                if(name.equals(arr[i].getName())){
                    System.out.print(arr[i].getXueHao()+" "+arr[i].getName()+" "+arr[i].getAge());
                }
            }
            System.out.println();
            //3.计算所有学生的平均年龄,最大年龄,最小年龄
            System.out.println("3.计算所有学生的平均年龄,最大年龄,最小年龄:");
            int ageSum=0;
            int ageMax=arr[0].getAge();
            int ageMin=arr[0].getAge();
            for(int i=0;i<arr.length;i++){
                ageSum+=arr[i].getAge();
                ageMax=ageMax>arr[i].getAge()?ageMax:arr[i].getAge();
                ageMin=ageMin<arr[i].getAge()?ageMin:arr[i].getAge();
            }
            System.out.println("所有学生的平均年龄:"+ageSum/arr.length);
            System.out.println("所有学生中的最大年龄:"+ageMax);
            System.out.println("所有学生中的最小年龄:"+ageMin);
            //4.如果存在名字叫张三的将名字改为张兵
            System.out.println("4.如果存在名字叫张三的将名字改为张兵:");
            for(int i=0;i<arr.length;i++){
                String temp="张三";
                if(temp.equals(arr[i].getName())){
                    arr[i].setName("张兵");
                    System.out.println("arr["+i+"]="+arr[i].getName());
                }
            }
    
            input.close();
        }
    }
    

    运行结果:
    这里写图片描述

    展开全文
  • 【java】java学习笔记之java常用类

    千次阅读 2019-08-01 17:09:45
    如下图所示为笔者总结的java常用类学习笔记,其中,附带有代码示例(未展开),方便理解记忆。需要源文件的请到我的资源中下载,下载地址:https://download.csdn.net/download/guaishounan/11451504 ...

    如下图所示为笔者总结的java常用类学习笔记,其中,附带有代码示例(未展开),方便理解记忆。需要源文件的请到我的资源中下载,下载地址:https://download.csdn.net/download/guaishounan/11451504

    展开全文
  • Java常用类笔记

    千次阅读 多人点赞 2021-02-07 15:49:29
    文章目录一、前言二、字符串相关1.String 一、前言 这篇技术博客是我复习尚硅谷JavaSE教程做的笔记总结,方便大家的学习同时也方便自己。博客内容非复制粘贴,纯手写。如果对你有帮助,欢迎点赞评论收藏! 二、...

    一、前言

    这篇技术博客是我复习尚硅谷JavaSE教程做的笔记总结,方便大家的学习同时也方便自己。博客内容非复制粘贴,纯手写。如果对你有帮助,欢迎点赞评论收藏

    二、String类

    1.理解String的不可变性

    String:字符串,使用""引起来表示

    1. String声明为final的,不能被继承
    2. String实现了Serializable接口:表示字符串是支持序列化
      实现了Comparable接口:表示String可以比较大小
    3. String在内部定义了final char[] value用于存储字符串数据
    4. String:代表不可变的字符序列。简称:不可变性。(只要对字符串内容进行任何修改,都必须重新造!)
      体现:
         1.当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值
         2.当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能在原有的value上进行赋值
         3.当调用String的replace()修改指定字符或字符串时,也需要重新指定内存区域赋值
    
    1. 通过字面量的方式(区别于new)给一个字符串赋值,此时的字符串值声明在字符串常量池
    2. 字符串常量池中是不会存储相同内容的字符串的。

    图解如下:
    在这里插入图片描述

    附加:JVM中字符串常量池存放位置说明

    JDK1.6:字符串常量池存储在方法区(永久区)
    JDK1.7:字符串常量池存储在堆空间
    JDK1.8:字符串常量池存储在方法区(元空间)
    

    2.String不同实例化方式对比

    String共有两种实例化的方式:

    1. 通过字面量定义的方式
    2. 通过new + 构造器方式
    /**
     * 面试题:String s = new String("abc");方式创建对象,在内存中创建了几个对象?
     *       两个:一个是堆空间中new结构,另一个是char[]对应的常量池中的数据:"abc"
     */
    public class StringTest {
        @Test
        public void test1(){
            //此时的s1和s2数据声明在方法区中的字符串常量池中
            String s1 = "abc";
            String s2 = "abc";
    
            //new + 构造器方式:此时的s3和s4保存的地址值,是数据在堆空间中开辟空间后对应的地址值
            String s3 = new String("abc");
            String s4 = new String("abc");
    
            System.out.println(s1 == s2); //true 因为字符串常量存储在方法区的常量池中,是唯一的(共享)
            System.out.println(s1 == s3); //false s1指向常量池中的地址,s3指向堆空间地址
            System.out.println(s1 == s4); //false s1指向常量池中的地址,s4指向对空间地址
            System.out.println(s3 == s4); //false s3和s4都指向堆空间地址,但是地址值不同
        }
    }
    

    总结:字符串分两种实例化方式,通过字面量实例化就存储在方法区的常量池中,通过new方式就存储在堆空间中。常量池中的常量是唯一且不可修改的,如果想使用新的常量,只能在池中创建新的!
    在这里插入图片描述

    3.String不同拼接操作的对比

    结论

    • 1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
    • 2.只要其中有一个是变量,结果就在堆中
    • 3.如果拼接的结果调用intern()方法,返回值就在常量池中
    public class StringTest {
        @Test
        public void test1(){
            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); //true 常量和常量拼接,地址依旧在常量池,所以指向同一个地址
            System.out.println(s3 == s5); //false 常量和变量拼接,地址就在堆空间中,所以没指向同一个地址
            System.out.println(s3 == s6); //false 同理
            System.out.println(s5 == s6); //false 同理
            System.out.println(s3 == s7); //false 同理
            System.out.println(s5 == s7); //false 同理
            System.out.println(s6 == s7); //false 同理
    
            String s8 = s5.intern(); //返回值得到的s8使用的常量池中已经存在的"JavaEEhadoop"
            System.out.println(s3 == s8); //true
        }
    
    	@Test
        public void test1(){
            String s1 = "javaEEhadoop";
            String s2 = "javaEE";
            String s3 = s2 + "hadoop";
            System.out.println(s1 == s3); //false
    
            final String s4 = "javaEE"; //s4是常量
            String s5 = s4 + "hadoop";
            System.out.println(s1 == s5); //true 原因:看结论1
        }
    }
    

    4.String常用方法

    1. int length():返回字符串的长度: return value.length
    2. char charAt(int index): 返回某索引处的字符return value[index]
    3. boolean isEmpty():判断是否是空字符串:return value.length == 0
    4. String toLowerCase():使用默认语言环境,将 String 中的所有字符转换为小写
    5. String toUpperCase():使用默认语言环境,将 String 中的所有字符转换为大写
    6. String trim():返回字符串的副本,忽略前导空白和尾部空白
    7. boolean equals(Object obj):比较字符串的内容是否相同
    8. boolean equalsIgnoreCase(String anotherString):与equals方法类似,忽略大小写
    9. String concat(String str):将指定字符串连接到此字符串的结尾。 等价于用“+”
    10. int compareTo(String anotherString):比较两个字符串的大小
    11. String substring(int beginIndex):返回一个新的字符串,它是此字符串的从beginIndex开始截取到最后的一个子字符串。
    12. String substring(int beginIndex, int endIndex) :返回一个新字符串,它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
    13. boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
    14. boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
    15. boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
    16. boolean contains(CharSequence s):当且仅当此字符串包含指定的 char 值序列时,返回 true
    17. int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引
    18. int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始
    19. int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
    20. int lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索
      注:indexOf和lastIndexOf方法如果未找到都是返回-1
    21. String replace(char oldChar, char newChar):返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
    22. String replace(CharSequence target, CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
    23. String replaceAll(String regex, String replacement) : 使 用 给 定 的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
    24. String replaceFirst(String regex, String replacement) : 使 用 给 定 的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
    25. boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。
    26. String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。
    27. String[] split(String regex, int limit):根据匹配给定的正则表达式来拆分此字符串,最多不超过limit个,如果超过了,剩下的全部都放到最后一个元素中。

    代码演示

    import org.junit.Test;
    
    
    public class StringTest {
        @Test
        public void test1(){
            //length()
            String s1 = "HelloWorld";
            System.out.println(s1.length()); //10
    
            //charAt()
            System.out.println(s1.charAt(0)); //H
            System.out.println(s1.charAt(9)); //d
    
            //isEmpty()
            System.out.println(s1.isEmpty()); //false
    
            //toLowerCase()
            String s2 = s1.toLowerCase();
            System.out.println(s2); //helloworld
    
            //toUpperCase()
            String s3 = s1.toUpperCase();
            System.out.println(s3); //HELLOWORLD
    
            //trim()
            String s4 = "     hello world     ";
            String s5 = s4.trim();
            System.out.println("---" + s4 + "---"); //---     hello world     ---
            System.out.println("---" + s5 + "---"); //---hello world---
        }
    
        @Test
        public void test2(){
            //equalsIgnoreCase()
            String s1 = "HelloWorld";
            String s2 = "helloworld";
            System.out.println(s1.equals(s2)); //false
            System.out.println(s1.equalsIgnoreCase(s2)); //true
    
            //concat()
            String s3 = "abc";
            String s4 = s3.concat("def");
            System.out.println(s4); //abcdef
    
            //compareTo()
            String s5 = "abc";
            String s6 = new String("abe");
            System.out.println(s5.compareTo(s6)); //涉及到字符串排序
    
            //substring()
            String s7 = "北京天安门广场";
            System.out.println(s7.substring(2)); //天安门广场
    
            //endIndex()
            System.out.println(s7.substring(2, 5)); //天安门
        }
    
        @Test
        public void test3(){
            //endsWith()
            String str1 = "helloworld";
            boolean b1 = str1.endsWith("ld");
            System.out.println(b1); //true
    
            //startsWith()
            boolean b2 = str1.startsWith("He");
            System.out.println(b2); //false
            boolean b3 = str1.startsWith("ll",2);
            System.out.println(b3); //true
    
            //contains()
            String str2 = "wo";
            System.out.println(str1.contains(str2)); //true
    
            //indexOf()
            System.out.println(str1.indexOf("lo")); //3
            System.out.println(str1.indexOf("lol")); //-1
            System.out.println(str1.indexOf("lo",5)); //-1
    
            //lastIndexOf()
            String str3 = "hellorworld";
            System.out.println(str3.lastIndexOf("or")); //7
            System.out.println(str3.lastIndexOf("or",6)); //4
    
            //什么情况下,indexOf(str)和lastIndexOf(str)返回值相同?
            //1.存在唯一的的一个str     2.不存在str
        }
    
        @Test
        public void test4(){
            //replace()
            String str1 = "北京尚硅谷教育北京";
            String str2 = str1.replace('北', '东');
            String str3 = str1.replace("北京", "上海");
            System.out.println(str1); //北京尚硅谷教育北京
            System.out.println(str2); //东京尚硅谷教育东京
            System.out.println(str3); //上海尚硅谷教育上海
        }
    }
    

    5.String类与其他结构之间的转换

    /**
     * 涉及到String类与其他结构之间的转换
     */
    public class StringTest {
        @Test
        public void test1(){
            //String--->基本数据类型、包装类
            String str1 = "123";
            int num = Integer.parseInt(str1); //123
    
            //基本数据类型、包装类--->String
            String str2 = String.valueOf(num); //"123"
            String str3 = num + "";
        }
    
        @Test
        public void test2(){
            /*
            String与char[]之间的转换
             */
    
    
            //String--->char[]:调用String的toCharArray()
            String str1 = "abc123";
            char[] charArray = str1.toCharArray();
            for (int i = 0; i < charArray.length; i++) {
                System.out.println(charArray[i]);
            }
    
            //char[]--->String:调用String的构造器
            char[] arr = new char[]{'h','e','l','l','o'};
            String str2 = new String(arr);
            System.out.println(str2); //hello
        }
    
        @Test
        public void test3() throws UnsupportedEncodingException {
            /*
            String与byte[]之间转换
    
            编码:字符串--->字节(看得懂--->看不懂)
            解码:编码的逆过程,字节--->字符串(看不懂的二进制数据--->看得懂)
            
            说明:解码时,要求解码使用的字符集必须与编码时使用的字符集一致,否则会出现乱码
             */
    
            //编码:String--->byte[]:调用
            String str1 = "abc123中国";
            byte[] bytes = str1.getBytes(); //使用默认的字符集(utf-8)进行编码
            //[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]
            System.out.println(Arrays.toString(bytes));
    
            byte[] gbks = str1.getBytes("gbk"); //使用gbk字符集进行编码
            //[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]
            System.out.println(Arrays.toString(gbks));
    
    
            //解码:byte[]--->String:调用String构造器
            String str2 = new String(bytes); //使用默认的字符集,进行解码
            System.out.println(str2); //abc123中国
    
            String str3 = new String(gbks);
            System.out.println(str3); //出现乱码,原因:编码集和解码集不一致!
    
            String str4 = new String(gbks, "gbk");
            System.out.println(str4); //没有出现乱码,原因:编码集和解码集一致!
        }
    }
    

    三、StringBuffer类和StringBuilder类

    1.StringBuffer分析(StringBuilder同理)

    StringBuffer类不同于String,其对象必须使用构造器生成。

    1. StringBuffer():初始容量为16的字符串缓冲区
    2. StringBuffer(int size):构造指定容量的字符串缓冲区
    3. StringBuffer(String capacity):将内容初始化为指定字符串内容
    String、StringBuffer、StringBuilder三者异同?
        String:不可变的字符序列;底层结构使用char[]存储
        StringBuffer:可变的字符序列,线程安全的,效率低;底层结构使用char[]存储
        StringBuilder:可变的字符序列,jdk5.0新增,线程不安全的,效率高;底层结构使用char[]存储
        
    	
    	String str = new String(); //char[] value = new char[0];
        String str1 = new String("abc"); //char[] value = new char[]{'a','b','c'};
    
        StringBuffer sb1 = new StringBuffer(); //char[] value = new char[16]; 底层创建了一个长度是16的数组
        sb1.append('a'); //value[0] = 'a';
        sb1.append('b'); //value[1] = 'b';
    
        StringBuffer sb2 = new StringBuffer("abc"); //char[] value = new char["abc".length() + 16];
    
        问题1:System.out.println(sb2.length()); //3
        问题2:扩容问题:如果要添加的数据底层数组盛不下了,那就需要扩容底层数组
              默认情况下,扩容为原来容量的2+ 2,同时将原有数组中的元素复制到新的数组中
    
        指导意义:在开发中,建议大家使用:StringBuffer(int capacity)StringBuilder(int capacity)
    

    注意:String、StringBuffer、StringBuilder三者之间如何转换?

    String-->StringBuffer、StringBuilder:
    			1.调用StringBuffer、StringBuilder构造器
    StringBuffer、StringBuilder-->String:
    			1.调用String构造器
    			2.StringBuffer、StringBuilder的toString()
    

    理解:关于StringBuffer和StringBuilder这两个类,它们之间除了类名不同,唯一的区别就是:是否同步(synchronized)

    2.StringBuffer常用方法(StringBuilder同理)

    String类中定了许多方法,StringBuffer中也有。但是StringBuffer还有一些独有的方法,我们来了解了解:

    1. StringBuffer append(xxx):提供了很多的append()方法,用于进行字符串拼接
    2. StringBuffer delete(int start,int end):删除指定位置的内容
    3. StringBuffer replace(int start, int end, String str):把[start,end)位置替换为str
    4. StringBuffer insert(int offset, xxx):在指定位置插入xxx
    5. StringBuffer reverse() :把当前字符序列逆转
    6. public int indexOf(String str)
    7. public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串1
    8. public int length()
    9. public char charAt(int n)
    10. public void setCharAt(int n ,char ch)

    代码展示

    public class StringTest {
    
        @Test
        public void test2(){
            //append()
            StringBuffer s1 = new StringBuffer("abc");
            s1.append(1);
            s1.append('1');
            System.out.println(s1); //abc11
    
            //delete()
            //s1.delete(2,4); //ab1
    
            //replace()
            //s1.replace(2,4,"hello"); //abhello1
    
            //insert()
            //s1.insert(2,false); //abfalsec11
    
            //reverse()
            //s1.reverse(); //11cba
    
            //sustring()
            //String s2 = s1.substring(1, 3); //bc
        }
    }
    

    总结:

    增:append(xxx)
    删:delete(int start,int end)
    改:setCharAt(int n ,char ch)
    查:charAt(int n)
    插:insert(int offset, xxx)
    长度:length()
    遍历:for() + charAt(int n)  /  toString()
    

    3.效率对比

    接下来我们探讨一下:String、StringBuffer、StringBuilder三者之间的效率对比

    代码展示:

    public class StringTest {
        @Test
        public void test2(){
            long startTime = 0L;
            long endTime = 0L;
            String text = "";
            StringBuffer buffer = new StringBuffer("");
            StringBuilder builder = new StringBuilder("");
    
            //开始对比
            //StringBuffer时间
            startTime = System.currentTimeMillis();
            for (int i = 0; i < 20000; i++) {
                buffer.append(String.valueOf(i));
            }
            endTime = System.currentTimeMillis();
            System.out.println("StringBuffer的执行时间:" + (endTime - startTime));
    
            //StringBuilder测试时间
            startTime = System.currentTimeMillis();
            for (int i = 0; i < 20000; i++) {
                builder.append(String.valueOf(i));
            }
            endTime = System.currentTimeMillis();
            System.out.println("StringBuilder的执行时间:" + (endTime - startTime));
    
            //String测试时间
            startTime = System.currentTimeMillis();
            for (int i = 0; i < 20000; i++) {
                text = text + i;
            }
            endTime = System.currentTimeMillis();
            System.out.println("String的执行时间:" + (endTime - startTime));
        }
    }
    

    运行结果如下:
    在这里插入图片描述

    总结
    效率由高到低排名为:StringBuilder > StringBuffer > String

    四、JDK8之前日期和时间API

    1.System.currentTimeMillis()

    代码展示:

    public class StringTest {
    
        //1.System类中的currentTimeMillis()
        @Test
        public void test1() {
            //返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
            //称为:时间戳
            long time = System.currentTimeMillis();
            System.out.println(time);
        }
    

    2.Date类

        /*
        java.util.Date类
                |---java.sql.Date类
    
        1.两个构造器的使用
            >构造器一:Date():创建一个对应当前时间Date对象
            >构造器二:创建指定毫秒数的Date对象
        2.两个方法的使用
            >toString():显示当前的年、月、日、时、分、秒
            >getTime():获取当前Date对象对应的毫秒数。(时间戳)
    
        3.java.sql.Date对应着数据库中的日期类型的变量
            >如何实例化
            >如何将java.util.Date转换为java.sql.Date对象
         */
    
        @Test
        public void test2(){
            //构造器一:Date():创建一个对应当前时间Date对象
            Date date1 = new Date();
            System.out.println(date1); //Tue Feb 09 14:10:37 CST 2021
            System.out.println(date1.getTime()); //1612851112558
    
            //构造器二:创建指定毫秒数的Date对象
            Date date2 = new Date(1612851112558L);
            System.out.println(date2);
    
            //创建java.sql.Date对象
            java.sql.Date date3 = new java.sql.Date(321312213L);
            System.out.println(date3.toString()); //1970-01-05
    
            //如何将java.util.Date转换为java.sql.Date对象
            //情况一:
            Date date4 = new java.sql.Date(123231312313L);
            java.sql.Date date5 = (java.sql.Date) date4;
            //情况二:
            Date date6 = new Date();
            java.sql.Date date7 = new java.sql.Date(date6.getTime());
        }
    }
    

    3.SimpleDateFormat类

    Date类的API不易于国际化,大部分被废弃了,java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

    格式化:
    1. SimpleDateFormat() :默认的模式和语言环境创建对象
    2. public SimpleDateFormat(String pattern):该构造器可以用参数pattern指定的格式创建一个对象
    3. public String format(Date date):方法格式化时间对象date
    
    解析:
    1. public Date parse(String source):从给定字符串的开始解析文本,以生成一个日期。
    

    代码展示:

    /**
     * JDK 8之前的日期时间的API测试
     * 1.System类中currentTimeMillis();
     * 2.java.util.Date和子类java.sql.Date
     * 3.SimpleDateFormat
     * 4.Calendar
     */
    public class DateTimeTest {
        /*
        SimpleDateFormat的使用:对日期Date类的格式化和解析
    
        1.两个操作:
            1.格式化:日期对象--->字符串
            2.解析:格式化逆过程,字符串--->日期对象
    
        2.SimpleDateFormat的实例化
    
         */
    
        @Test
        public void testSimpleDateFormat() throws ParseException {
            //实例化SimpleDateFormat:使用默认构造器
            SimpleDateFormat sdf = new SimpleDateFormat();
    
            //格式化:日期--->字符串
            Date date = new Date();
            String format = sdf.format(date);
            System.out.println(format);
    
            //解析:字符串--->日期
            String str = "21-07-07 上午12:00";
            Date date1 = sdf.parse(str);
            System.out.println(date1);
    
    
            //按照指定的方式格式化和解析:调用带参的构造器(我们主要使用这种方式!)
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            //格式化
            String format1 = sdf1.format(date);
            System.out.println(format1); //2021-02-10 01:54:58
            //解析:要求字符串必须符合SimpleDateFormat识别的格式(通过构造器参数体现)
            //否则,抛异常
            Date date2 = sdf1.parse("2021-02-10 01:54:58");
            System.out.println(date2); //Wed Feb 10 01:54:58 CST 2021
        }
    }
    

    4.Calendar类

    Calendar是一个抽象基类,主用用于完成日期字段之间相互操作的功能。

    获取Calendar实例的方法:
    1. 使用Calendar.getInstance()方法
    2. 调用它的子类GregorianCalendar的构造器。
    

    代码展示:

    /**
     * JDK 8之前的日期时间的API测试
     * 1.System类中currentTimeMillis();
     * 2.java.util.Date和子类java.sql.Date
     * 3.SimpleDateFormat
     * 4.Calendar
     */
    public class DateTimeTest {
        /*
         Calendar日历类(抽象类)的使用
         */
    
        @Test
        public void testCalendar(){
            //1.实例化
            //方式一:创建其子类(GregorianCalendar)的对象
            //方式二:调用其静态方法getInstance()
            Calendar calendar = Calendar.getInstance();
            System.out.println(calendar.getClass());  //class java.util.GregorianCalendar
    
            //2.常用方法
            //get()
            int days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
            System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
    
            //set()
            //Calendar可变性
            calendar.set(Calendar.DAY_OF_MONTH,22);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
    
            //add()
            calendar.add(Calendar.DAY_OF_MONTH,3);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
    
            //getTime():日历类--->Date
            Date date = calendar.getTime();
            System.out.println(date);
    
            //setTime():Date--->日历类
            Date date1 = new Date();
            calendar.setTime(date1);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
        }
    }
    

    注意

    1. 获取月份时:一月是0,二月是1,以此类推,12月是11
    2. 获取星期时:周日是1,周二是2 , 。。。。周六是7

    五、JDK8中新日期和时间API

    为何引进新的API?
    JDK 1.0中包含了一个java.util.Date类,但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们有许多缺点

    可变性:像日期和时间这样的类应该是不可变的。
    偏移性:Date中的年份是从1900开始的,而月份都从0开始。
    格式化:格式化只对Date有用,Calendar则不行。
    此外,它们也不是线程安全的;不能处理闰秒等。
    

    总结:对日期和时间的操作一直是Java程序员最痛苦的地方之一。

    正因如此,我们才需要引进新的API,Java 8中引入的java.time API 已经纠正了过去的缺陷,将来很长一段时间内它都会为我们服务。

    1. LocalDate、LocalTime、LocalDateTime

    LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类,它们的实例是不可变的对象,分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间,并不包含当前的时间信息,不包含与时区相关的信息。

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

    代码展示:

    public class DateTimeTest {
        /*
         LocalDate、LocalTime、LocalDateTime的使用
         说明:
            1.LocalDateTime相较于LocalDate、LocalTime,使用频率更高
            2.类似于Calendar类
         */
    
        @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); //2020-10-06T13:23:43
    
            //getXxx():获取相关的属性
            System.out.println(localDateTime.getDayOfMonth());
            System.out.println(localDateTime.getDayOfWeek());
            System.out.println(localDateTime.getMonth());
            System.out.println(localDateTime.getMonthValue());
            System.out.println(localDateTime.getMinute());
    
            //体现不可变性
            //withXxx():设置相关的属性
            LocalDate localDate1 = localDate.withDayOfMonth(22);
            System.out.println(localDate);
            System.out.println(localDate1);
    
            LocalDateTime localDateTime2 = localDateTime.withHour(4);
            System.out.println(localDateTime);
            System.out.println(localDateTime2);
    
    
            //不可变性
            LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
            System.out.println(localDateTime);
            System.out.println(localDateTime3);
    
            LocalDateTime localDateTime4 = localDateTime.minusDays(6);
            System.out.println(localDateTime);
            System.out.println(localDateTime4);
        }
    }
    

    2.Instant类

    Instant:时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳。

    代码展示:

    public class DateTimeTest {
        /*
        Instant的使用
        类似于java.util.Date类
         */
    
        @Test
        public void test1(){
            //now():获取本初子午线对应的标准时间
            Instant instant = Instant.now();
            System.out.println(instant); //2021-02-10T23:35:44.312Z
    
            //添加时间的偏移量
            OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
            System.out.println(offsetDateTime); //2021-02-11T07:35:44.312+08:00
    
            //toEpochMilli():获取自1970年1月1日0时0分0秒(UTC)开始的毫秒数 --->Date类的getTime()
            long milli = instant.toEpochMilli();
            System.out.println(milli);
    
            //ofEpochMilli():通过给定的毫秒数,获取Instant实例 --->Date(long millis)
            Instant instant1 = Instant.ofEpochMilli(321321312312L);
            System.out.println(instant1);
        }
    }
    

    3.DateTimeFormatter类

    代码展示:

    public class DateTimeTest {
        /*
        DateTimeFormatter:格式化或解析日期、时间
        类似于SimpleDateFormat
         */
    
        @Test
        public void test1(){
            //实例化方式
            //方式一:ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
            DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
            //格式化:日期--->字符串
            LocalDateTime localDateTime = LocalDateTime.now();
            String str1 = formatter.format(localDateTime);
            System.out.println(localDateTime);
            System.out.println(str1);
            //解析:字符串--->日期
            TemporalAccessor parse = formatter.parse("2021-02-11T07:52:55.315");
            System.out.println(parse);
    
            //方式二:
            //本地化相关的格式。如:ofLocalizedDateTime()
            //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
            DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
            //格式化
            String str2 = formatter1.format(localDateTime);
            System.out.println(str2);//2019年2月18日 下午03时47分16秒
    
    
            //本地化相关的格式。如:ofLocalizedDate()
            //FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
            DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
            //格式化
            String str3 = formatter2.format(LocalDate.now());
            System.out.println(str3);//2019-2-18
    
    
            //重点:方式三:自定义的格式。如:ofPattern(“yyyy-MM-dd hh:mm:ss”)
            DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
            //格式化
            String str4 = formatter3.format(LocalDateTime.now());
            System.out.println(str4);
    
            //解析
            TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
            System.out.println(accessor);
    
        }
    }
    

    六、Java比较器

    在Java中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题。

    Java实现对象排序的方式有两种

    1. 自然排序:java.lang.Comparable
    2. 定制排序:java.util.Comparator

    1.自然排序:Comparable接口

    Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

    实现 Comparable 的类必须实现 compareTo(Object obj) 方法,两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj,则返回正整数,如果当前对象this小于形参对象obj,则返回负整数,如果当前对象this等于形参对象obj,则返回零。

    实现Comparable接口的对象列表(和数组)可以通过 Collections.sort 或Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素,无需指定比较器。

    代码展示:

    /**
     * 一、说明:java中的对象,正常情况下,只能进行比较:== 或 != 。不能使用> 或 <
     *         但是在开发场景中,我们需要对多个对象进行排序,言外之意,需要比较对象的大小
     *         如何实现?使用两个接口中任何一个:Comparable 或 Comparator
     *
     * 二、Comparable接口的使用
     *
     */
    public class CompareTest {
        /*
        Comparable接口的使用举例:自然排序
        1.像String、包装类等实现了Comparable接口,重写了compareTo(),给出了比较两个对象大小的方式
        2.像String、包装类重写compareTo()方法以后,进行了从小到大的排列
        3.重写compareTo()的规则:
            如果当前对象this大于形参对象obj,则返回正整数,
            如果当前对象this小于形参对象obj,则返回负整数,
            如果当前对象this等于形参对象obj,则返回零。
        4.对于自定义类来说,如果需要排序,我们可以让自定义类实现Comparable接口,
        重写compareTo(obj)方法,在compareTo(obj)方法中指明如何排序
         */
        @Test
        public void test1(){
            String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
            Arrays.sort(arr);
            System.out.println(Arrays.toString(arr));
        }
    
    
        @Test
        public void test2(){
            Goods[] arr = new Goods[5];
            arr[0] = new Goods("lenovoMouse",34);
            arr[1] = new Goods("dellMouse",43);
            arr[2] = new Goods("xiaomiMouse",12);
            arr[3] = new Goods("huaweiMouse",65);
            arr[4] = new Goods("microsoftmouse",43);
    
            Arrays.sort(arr);
            System.out.println(Arrays.toString(arr));
        }
    }
    
    =================================================================
    /**
     * 商品类
     */
    public class Goods implements Comparable {
        private String name;
        private double price;
    
        //构造器、getter、setter、toString()方法略
     
        //指明商品比较大小的方式:按照价格从低到高排序,
        //再按照商品名称从低到高排序
        @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 0;
                    return this.name.compareTo(goods.name);
                }
    
                //方式二
                //return Double.compare(this.price,goods.price);
            }
            throw new RuntimeException("传入的数据类型不一致!");
        }
    }
    

    2.定制排序:Comparator接口

    当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码,或者实现了java.lang.Comparable接口的排序规则不适合当前的操作,那么可以考虑使用 Comparator 的对象来排序

    重写compare(Object o1,Object o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。

    可以将 Comparator 传递给 sort 方法(如 Collections.sort 或 Arrays.sort),从而允许在排序顺序上实现精确控制。

    还可以使用 Comparator 来控制某些数据结构(如有序 set或有序映射)的顺序,或者为那些没有自然顺序的对象 collection 提供排序。

    代码展示:

    /**
     * 一、说明:java中的对象,正常情况下,只能进行比较:== 或 != 。不能使用> 或 <
     *         但是在开发场景中,我们需要对多个对象进行排序,言外之意,需要比较对象的大小
     *         如何实现?使用两个接口中任何一个:Comparable 或 Comparator
     *
     * 二、Comparable接口与Comparator接口使用对比:
     * Comparable接口的方式一旦指定,保证该接口实现类的对象在任何位置都可以比较大小
     * Comparator接口属于临时性的比较
     */
    public class CompareTest {
        /*
        Comparator接口的使用:定制排序
        1.背景:当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码,
        或者实现了java.lang.Comparable接口的排序规则不适合当前的操作,那么可以考虑使用 Comparator 的对象来排序
        2.重写compare(Object o1,Object o2)方法,比较o1和o2的大小:
        如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表o1小于o2。
         */
    
        @Test
        public void test(){
            String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
            Arrays.sort(arr, new Comparator(){
    
                //按照字符串从大到小的顺序排列
                @Override
                public int compare(Object o1, Object o2) {
                    if (o1 instanceof String && o2 instanceof String){
                        String s1 = (String) o1;
                        String s2 = (String) o2;
                        return -s1.compareTo(s2);
                    }
                    //return 0;
                    throw new RuntimeException("输入数据类型不一致");
                }
            });
            System.out.println(Arrays.toString(arr));
        }
    
        @Test
        public void test1(){
            Goods[] arr = new Goods[6];
            arr[0] = new Goods("lenovoMouse",34);
            arr[1] = new Goods("dellMouse",43);
            arr[2] = new Goods("xiaomiMouse",12);
            arr[3] = new Goods("huaweiMouse",65);
            arr[4] = new Goods("huaweiMouse",224);
            arr[5] = new Goods("microsoftmouse",43);
    
            Arrays.sort(arr, new Comparator() {
                //指明商品比较大小的方式:按照产品名称从低到高排序,再按照价格从高到低排序
                @Override
                public int compare(Object o1, Object o2) {
                    if (o1 instanceof Goods && o2 instanceof Goods){
                        Goods g1 = (Goods) o1;
                        Goods g2 = (Goods) o2;
                        if (g1.getName().equals(g2.getName())){
                            return -Double.compare(g1.getPrice(),g2.getPrice());
                        }else {
                            return g1.getName().compareTo(g2.getName());
                        }
                    }
                    throw new RuntimeException("输入数据类型不一致");
                }
            });
    
            System.out.println(Arrays.toString(arr));
        }
    }
    
    

    七、System类

    System类代表系统,系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

    由于该类的构造器是private的,所以无法创建该类的对象,也就是无法实例化该类。其内部的成员变量和成员方法都是static的,所以也可以很方便的进行调用。

    System类内部包含in、out和err三个成员变量,分别代表标准输入流
    (键盘输入),标准输出流(显示器)和标准错误输出流(显示器)。

    成员方法:

    1. native long currentTimeMillis()
    2. void exit(int status)
    3. void gc()
    4. String getProperty(String key)
    

    代码展示:

    public class SystemTest {
        @Test
        public void test(){
            String javaVersion = System.getProperty("java.version");
            System.out.println("java的version:" + javaVersion);
    
            String javaHome = System.getProperty("java.home");
            System.out.println("java的home:" + javaHome);
    
            String osName = System.getProperty("os.name");
            System.out.println("os的name:" + osName);
    
            String osVersion = System.getProperty("os.version");
            System.out.println("os的version:" + osVersion);
    
            String userName = System.getProperty("user.name");
            System.out.println("user的name:" + userName);
    
            String userHome = System.getProperty("user.home");
            System.out.println("user的home:" + userHome);
    
            String userDir = System.getProperty("user.dir");
            System.out.println("user的dir:" + userDir);
        }
    }
    

    输出结果如下:
    在这里插入图片描述

    八、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类

    大于基本数据类型的整数,如果要表示再大的整数,不管是基本数据类型还是他们的包装类都无能为力,更不用说进行运算了。

    java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物,并提供 java.lang.Math 的所有相关方法。另外,BigInteger 还提供以下运算:模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

    构造器
    BigInteger(String val):根据字符串构建BigInteger对象

    常用方法:

    1. public BigInteger abs():返回此 BigInteger 的绝对值的 BigInteger
    2. BigInteger add(BigInteger val) :返回其值为 (this + val) 的 BigInteger
    3. BigInteger subtract(BigInteger val) :返回其值为 (this - val) 的 BigInteger
    4. BigInteger multiply(BigInteger val) :返回其值为 (this * val) 的 BigInteger
    5. BigInteger divide(BigInteger val) :返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。
    6. BigInteger remainder(BigInteger val) :返回其值为 (this % val) 的 BigInteger。
    7. BigInteger[] divideAndRemainder(BigInteger val):返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。
    8. BigInteger pow(int exponent) :返回其值为 (thisexponent) 的 BigInteger。

    十、BigDecimal类

    一般的Float类和Double类可以用来做科学计算或工程计算,但在商业计算中,要求数字精度比较高,故用到java.math.BigDecimal类

    BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

    构造器:
    public BigDecimal(double val)
    public BigDecimal(String val)

    常用方法:

    1. public BigDecimal add(BigDecimal augend)
    2. public BigDecimal subtract(BigDecimal subtrahend)
    3. public BigDecimal multiply(BigDecimal multiplicand)
    4. public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

    代码展示:

    public class SystemTest {
        @Test
        public void test(){
            BigInteger bi = new BigInteger("12421312312333241123");
            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));
        }
    }
    
    展开全文
  • Java常用类之Calendar类和GregorianCalendar类 20150802 Calendar类和GregorianCalendar类 -->GregorianCalendar(公历)是Calendar的一个具体子类,提供了世界上大多数国家/地区使用的标准日历系统。  ...
  • Java常用类和方法重点总结

    千次阅读 2015-12-20 20:08:01
    Java常用类和方法重点总结 作者:数据分析玩家 1、简述Java中内存分配的问题 1>凡是new()出来的东西,都是在堆中进行分配的 2>局部变量【数据类型+变量名】都是在栈中进行分配的 3>静态变量【static】和字符...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,698
精华内容 29,479
关键字:

java常用类

java 订阅