java基础总结_07

最新推荐文章于 2021-07-17 16:02:17 发布

BriskLyer

最新推荐文章于 2021-07-17 16:02:17 发布

阅读量379

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq_27280457/article/details/52023299

版权

Java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

java常用类

Object类

(1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。
(2)Object类的构造方法有一个，并且是无参构造
    这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造
(3)要掌握的方法：
    A:toString()
        返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。
        这个表示其实是没有意义的，一般子类都会重写该方法。
        如何重写呢?过程我也讲解过了，基本上就是要求信息简单明了。
        但是最终还是自动生成。
    B:equals()
        比较两个对象是否相同。默认情况下，比较的是地址值是否相同。
        而比较地址值是没有意义的，所以，一般子类也会重写该方法。
        重写过程，我也详细的讲解和分析了。
        但是最终还是自动生成。
(4)要了解的方法：
    A:hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。
    B:getClass() 返回对象的字节码文件对象，反射中我们会详细讲解    
    C:finalize() 用于垃圾回收，在不确定的时间
    D:clone() 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。
(5)两个注意问题；
    A:直接输出一个对象名称，其实默认调用了该对象的toString()方法。
    B:面试题 
        ==和equals()的区别?
        A:==
            基本类型：比较的是值是否相同
            引用类型：比较的是地址值是否相同
        B:equals()
            只能比较引用类型。默认情况下，比较的是地址值是否相同。
            但是，我们可以根据自己的需要重写该方法。

String类的概述和使用

(1)多个字符组成的一串数据。
    其实它可以和字符数组进行相互转换。
(2)构造方法：
    A:public String()
    B:public String(byte[] bytes)
    C:public String(byte[] bytes,int offset,int length)
    D:public String(char[] value)
    E:public String(char[] value,int offset,int count)
    F:public String(String original)
    下面的这一个虽然不是构造方法，但是结果也是一个字符串对象
    G:String s = "hello";
(3)字符串的特点
    A:字符串一旦被赋值，就不能改变。
        注意：这里指的是字符串的内容不能改变，而不是引用不能改变。
    B:字面值作为字符串对象和通过构造方法创建对象的不同
        String s = new String("hello");和String s = "hello"的区别?
(4)字符串的面试题(看程序写结果)
    A:==和equals()
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2);// false
        System.out.println(s1.equals(s2));// true

        String s3 = new String("hello");
        String s4 = "hello";
        System.out.println(s3 == s4);// false
        System.out.println(s3.equals(s4));// true

        String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5 == s6);// true
        System.out.println(s5.equals(s6));// true
    B:字符串的拼接
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3 == s1 + s2);// false
        System.out.println(s3.equals((s1 + s2)));// true

        System.out.println(s3 == "hello" + "world");// false 这个我们错了，应该是true
        System.out.println(s3.equals("hello" + "world"));// true
(5)字符串的功能(自己补齐方法中文意思)
    A:判断功能
        boolean equals(Object obj)
        boolean equalsIgnoreCase(String str)
        boolean contains(String str)
        boolean startsWith(String str)
        boolean endsWith(String str)
        boolean isEmpty()
    B:获取功能
        int length()
        char charAt(int index)
        int indexOf(int ch)
        int indexOf(String str)
        int indexOf(int ch,int fromIndex)
        int indexOf(String str,int fromIndex)
        String substring(int start)
        String substring(int start,int end)
    C:转换功能
        byte[] getBytes()
        char[] toCharArray()
        static String valueOf(char[] chs)
        static String valueOf(int i)
        String toLowerCase()
        String toUpperCase()
        String concat(String str)
    D:其他功能
        a:替换功能 
            String replace(char old,char new)
            String replace(String old,String new)
        b:去空格功能
            String trim()
        c:按字典比较功能
            int compareTo(String str)
            int compareToIgnoreCase(String str) 
(6)字符串的案例
    A:模拟用户登录
    B:字符串遍历
    C:统计字符串中大写，小写及数字字符的个数
    D:把字符串的首字母转成大写，其他小写
    E:把int数组拼接成一个指定格式的字符串
    F:字符串反转
    G:统计大串中小串出现的次数

StringBuffer

(1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了
   一个字符串缓冲区类。StringBuffer供我们使用。
(2)StringBuffer的构造方法
    A:StringBuffer()
    B:StringBuffer(int size)
    C:StringBuffer(String str)
(3)StringBuffer的常见功能(自己补齐方法的声明和方法的解释)
    A:添加功能
    B:删除功能
    C:替换功能
    D:反转功能
    E:截取功能(注意这个返回值)
(5)面试题
    小细节：
        StringBuffer：同步的，数据安全，效率低。
        StringBuilder：不同步的，数据不安全，效率高。
    A:String,StringBuffer,StringBuilder的区别
    B:StringBuffer和数组的区别?
(6)注意的问题：
    String作为形式参数，StringBuffer作为形式参数。

数组高级以及Arrays

(1)排序
    A:冒泡排序
        相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

        public static void bubbleSort(int[] arr) {
            for(int x=0; x<arr.length-1; x++) {
                for(int y=0; y<arr.length-1-x; y++) {
                    if(arr[y] > arr[y+1]) {
                        int temp = arr[y];
                        arr[y] = arr[y+1];
                        arr[y+1] = temp;
                    }
                }
            }
        }

    B:选择排序
        把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。

        public static void selectSort(int[] arr) {
            for(int x=0; x<arr.length-1; x++) {
                for(int y=x+1; y<arr.length; y++) {
                    if(arr[y] < arr[x]) {
                        int temp = arr[x];
                        arr[x] = arr[y];
                        arr[y] = temp;
                    }
                }
            }
        }
(2)查找
    A:基本查找
        针对数组无序的情况

        public static int getIndex(int[] arr,int value) {
            int index = -1;

            for(int x=0; x<arr.length; x++) {
                if(arr[x] == value) {
                    index = x;
                    break;
                }
            }

            return index;
        }
    B:二分查找(折半查找)
        针对数组有序的情况(千万不要先排序，在查找)

        public static int binarySearch(int[] arr,int value) {
            int min = 0;
            int max = arr.length-1;
            int mid = (min+max)/2;

            while(arr[mid] != value) {
                if(arr[mid] > value) {
                    max = mid - 1;
                }else if(arr[mid] < value) {
                    min = mid + 1;
                }

                if(min > max) {
                    return -1;
                }

                mid = (min+max)/2;
            }

            return mid;
        }
(3)Arrays工具类
    A:是针对数组进行操作的工具类。包括排序和查找等功能。
    B:要掌握的方法(自己补齐方法)
        把数组转成字符串：
        排序：
        二分查找：
(4)Arrays工具类的源码解析
(5)把字符串中的字符进行排序
    举例：
        "edacbgf"
        得到结果
        "abcdefg"

Integer

(1)为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型
    byte        Byte
    short       Short
    int         Integer
    long        Long
    float       Float
    double      Double
    char        Character
    boolean     Boolean
(2)Integer的构造方法
    A:Integer i = new Integer(100);
    B:Integer i = new Integer("100");
        注意：这里的字符串必须是由数字字符组成
(3)String和int的相互转换
    A:String -- int
        Integer.parseInt("100");
    B:int -- String
        String.valueOf(100);
(4)其他的功能(了解)
    进制转换
(5)JDK5的新特性
    自动装箱    基本类型--引用类型
    自动拆箱    引用类型--基本类型

    把下面的这个代码理解即可：
        Integer i = 100;
        i += 200;
(6)面试题
    -128到127之间的数据缓冲池问题

Character

(1)Character构造方法    
    Character ch = new Character('a');
(2)要掌握的方法：
    A:判断给定的字符是否是大写
    B:判断给定的字符是否是小写
    C:判断给定的字符是否是数字字符
    D:把给定的字符转成大写
    E:把给定的字符转成小写

正则表达式

(1)就是符合一定规则的字符串
(2)常见规则
    A:字符
        x 字符 x。举例：'a'表示字符a
        \\ 反斜线字符。
        \n 新行（换行）符 ('\u000A') 
        \r 回车符 ('\u000D')

    B:字符类
        [abc] a、b 或 c（简单类） 
        [^abc] 任何字符，除了 a、b 或 c（否定） 
        [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
        [0-9] 0到9的字符都包括

    C:预定义字符类
        . 任何字符。我的就是.字符本身，怎么表示呢? \.
        \d 数字：[0-9]
        \w 单词字符：[a-zA-Z_0-9]
            在正则表达式里面组成单词的东西必须有这些东西组成

    D:边界匹配器
        ^ 行的开头 
        $ 行的结尾 
        \b 单词边界
            就是不是单词字符的地方。
            举例：hello world?haha;xixi

    E:Greedy 数量词 
        X? X，一次或一次也没有
        X* X，零次或多次
        X+ X，一次或多次
        X{n} X，恰好 n 次 
        X{n,} X，至少 n 次 
        X{n,m} X，至少 n 次，但是不超过 m 次 
(3)常见功能：
    A:判断功能
        String类的public boolean matches(String regex)
    B:分割功能
        String类的public String[] split(String regex)
    C:替换功能
        String类的public String replaceAll(String regex,String replacement)
    D:获取功能
        Pattern和Matcher
            Pattern p = Pattern.compile("a*b");
            Matcher m = p.matcher("aaaaab");

            find():查找存不存在
            group():获取刚才查找过的数据
(4)案例
    A:判断电话号码和邮箱
    B:按照不同的规则分割数据
    C:把论坛中的数字替换为*
    D:获取字符串中由3个字符组成的单词

Math

(1)针对数学运算进行操作的类
(2)常见方法(自己补齐)
    A:绝对值
    B:向上取整
    C:向下取整
    D:两个数据中的大值
    E:a的b次幂
    F:随机数
    G:四舍五入
    H:正平方根
(3)案例：
    A:猜数字小游戏
    B:获取任意范围的随机数

Random

(1)用于产生随机数的类
(2)构造方法:
    A:Random() 默认种子，每次产生的随机数不同
    B:Random(long seed) 指定种子，每次种子相同，随机数就相同
(3)成员方法:
    A:int nextInt() 返回int范围内的随机数
    B:int nextInt(int n) 返回[0,n)范围内的随机数

BigInteger

(1)针对大整数的运算
(2)构造方法 
    A:BigInteger(String s)
(3)成员方法(自己补齐)
    A:加
    B:减
    C:乘
    D:除
    E:商和余数

BigDecimal

(1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)
(2)构造方法
    A:BigDecimal(String s)
(3)成员方法：
    A:加
    B:减
    C:乘
    D:除
    E:自己保留小数几位

Date/DateFormat

(1)Date是日期类，可以精确到毫秒。
    A:构造方法
        Date()
        Date(long time)
    B:成员方法
        getTime()
        setTime(long time)
    C:日期和毫秒值的相互转换
    案例：你来到这个世界多少天了?
(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat
    A:SimpleDateFormat(String pattern) 给定模式
        yyyy-MM-dd HH:mm:ss
    B:日期和字符串的转换
        a:Date -- String
            format()

        b:String -- Date
            parse()
    C:案例：
        制作了一个针对日期操作的工具类。

Calendar

(1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
(2)如何得到一个日历对象呢?
    Calendar rightNow = Calendar.getInstance();
    本质返回的是子类对象
(3)成员方法
    A:根据日历字段得到对应的值
    B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
    C:设置日历对象的年月日
(4)案例：
    计算任意一年的2月份有多少天?

BriskLyer

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java基础总结_07

java常用类Object类(1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。(2)Object类的构造方法有一个，并且是无参构造这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造(3)要掌握的方法： A:toString() 返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。
复制链接

扫一扫

专栏目录