GVKun编程网logo

13、java——常用类（java 常用类）

30

对于想了解13、java——常用类的读者，本文将是一篇不可错过的文章，我们将详细介绍java常用类，并且为您提供关于10、Java——内部类、12、Java——异常、13_Java常用类、13、Jav

对于想了解13、java——常用类的读者，本文将是一篇不可错过的文章，我们将详细介绍java 常用类，并且为您提供关于10、Java—— 内部类、12、Java——异常、13_Java 常用类、13、Java的集合的有价值信息。

本文目录一览：

13、java——常用类（java 常用类）

13、java——常用类（java 常用类）

​

  1.  枚举类型  

描述一种事物的所有情况|所有可能|所有实例

（1）通过enum关键字定义枚举类型

（2）枚举的成员,字段都作为当前枚举类型的实例存在,默认被public static final修饰

（3）定义的枚举类型都会隐式的继承自java.lang.Enum 这是所有Java语言枚举类型的公共基类。

（4）在枚举类型中构造器默认私有

（5）java是值传递：基本数据类型的数据值，引用数据类型的地址值​​

 

​​

2、File 路径或者文件的抽象的表现形式

    注意:java中路径的分隔符可以使用: \\ / //

public static void main(String[] args) throws IOException {
        //File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
        File file1 = new File("D:\\test.txt");
        File file2 = new File("D:\\AAA");
        File file3 = new File("D:/");
        //File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。
        File file4 = new File(file3,"test.txt");

        ////File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。
        File file5 = new File("D://AAA","BBB");

        File file6 = new File("D://haha.txt");

        System.out.println(file1);
        System.out.println(file2);
        System.out.println(file4);

        System.out.println(file1.equals(file4));
        System.out.println(file2.equals(file5));
        System.out.pri..............

10、Java—— 内部类

10、Java—— 内部类

​




..............

12、Java——异常

12、Java——异常

​

 1、异常处理方案:

        异常抛出 : throws 把异常抛出到上一层,谁调用谁解决

        异常捕获 : try..catch

            try{

                有可能出现异常的代码;

            }catch(FileNotFoundException e){

                处理异常代码;

            }catch(NullPointerException e){

                处理异常代码;

            }catch(Exception e){

                所有异常都能接收;

            }finally{

                无论try中是否会出现异常,都会执行finally中的代码

                //资源的关闭等代码

            }

一个try的后面可以接 1~n个catch，try中如果一旦出现异常,try下面的代码不会执行,直接进入catch的判断，catch从上到下一次判断,满足哪一个catch捕获的类型,就执行对应的语句体，异常一旦捕获,程序执行过程中出现的异常按照指定方案解决,不会影响后续代码的执行

2、自定义异常: 

自定义的异常类型

所有自定义的异常类型必须直接或者间接继承自Exception

如果自定义异常为运行时期异常,需要直接或者间接的继承自RuntimeException

throw 制造异常

 

3、常用类 --> 字符串

（1）String 不可变长字符序列

（2）StringBuilder 可变长字符序列,线程不安全|不同步,效率较高

（3）StringBuffer  可变长字符序列,线程安全|同步,效率较低

（4）学些一个类:

①类的作用 类的继承体系

②构造器

③方法(静态方法|成员方法)

（5）String类表示字符串。 Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例。

（6）String str = "abc";  创建一个字符串对象"abc",字符串常量 -->字符串常量池中

（7）String str2 = new String("haha"); 2个对象  第1个new->在堆中   第2个"haha"-->字符串常量池中

（8）String str2 = new String("abc"); 1个对象  第1个new->在堆中   "abc"->上面已经使用过,字符串常量池中已经存在

（9）字符串底层:

​​​​jdk11-->使用private final byte[] value; 字节数组存储字符串中的字符数据，jdk8--> private final char[] value;字符数组

4、可变长字符序列

    （1）StringBuilder : 线程不安全,但不保证同步,相对效率较高，适合使用在单线程下大量操作字符串,效率高

    （2）StringBuffer : 线程安全的,相对效率较低

        多线程下大量操作字符串建议使用StringBuffer

    （3）String : 少量修改字符串,适合使用String,因为表示字符串String对象简单,功能强大的API

    （4）效率: StringBuilder > StringBuffer > String

13_Java 常用类

13_Java 常用类

13_Java 常用类

String 对象的字符内容是存储在一个 final 字符数组 value [] 中，是不可变的字符序列。

String s1="abc"; // 存储在字符串常量池中

String s2 = new String ("abc"); // 存储在堆中 value 的地址指向常量池中的字符串

String s3 = s1 +"def"; // 右边有变量名参与，是在堆中

如果拼接的结果调用 intern () 方法，返回值就在常量池中

新生区 java heap space 异常

永久区（方法区、元空间）PermGen space 异常

int length ()：返回字符串的长度： return value.length
char charAt (int index)： 返回某索引处的字符 return value [index]
boolean isEmpty ()：判断是否是空字符串：return value.length == 0
String toLowerCase ()：使用默认语言环境，将 String 中的所有字符转换为小写
String toUpperCase ()：使用默认语言环境，将 String 中的所有字符转换为大写
String trim ()：返回字符串的副本，忽略前导空白和尾部空白
boolean equals (Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase (String anotherString)：与 equals 方法类似，忽略大小写
String concat (String str)：将指定字符串连接到此字符串的结尾。 等价于用 “+”
int compareTo (String anotherString)：比较两个字符串的大小
String substring (int beginIndex)：返回一个新的字符串，它是此字符串的从 beginIndex 开始截取到最后的一个子字符串。
String substring (int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从 beginIndex 开始截取到 endIndex (不包含) 的一个子字符串，左闭右开 [a,b)，a<=x<b。

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)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf 和 lastIndexOf 方法如果未找到都是返回 - 1

替换：
String replace (char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace (CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String replaceAll (String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst (String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
匹配:
boolean matches (String regex)：告知此字符串是否匹配给定的正则表达式。
切片：
String [] split (String regex)：根据给定正则表达式的匹配拆分此字符串。
String [] split (String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过 limit 个，如果超过了，剩下的全部都放到最后一个元素中。

String 与基本数据类型、包装类之间的转换。
String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx (str)
基本数据类型、包装类 --> String: 调用 String 重载的 valueOf (xxx)

String 与 char [] 之间的转换
String --> char []: 调用 String 的 toCharArray ()
char [] --> String: 调用 String 的构造器

String 与 byte [] 之间的转换
编码：String --> byte []: 调用 String 的 getBytes ()
解码：byte [] --> String: 调用 String 的构造器
编码：字符串 --> 字节  (看得懂 ---> 看不懂的二进制数据)
解码：编码的逆过程，字节 --> 字符串 （看不懂的二进制数据 ---> 看得懂）
说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

String: 不可变的字符序列；底层使用 char [] 存储
StringBuffer: 可变的字符序列；线程安全的，效率低；底层使用 char [] 存储。扩容 2 倍加 2。
StringBuilder: 可变的字符序列；jdk5.0 新增的，线程不安全的，效率高；底层使用 char [] 存储

StringBuilder 清空的三种方法:

1. StringBuilder sb2 = new StringBuilder();
2. sb.delete( 0, sb.length() );
3. sb3.setLength( 0 );
效率分别是2>3>1.

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

long time = System.currentTimeMillis (); // 时间戳，返回当前时间与 1970 年 1 月 1 日 0 时 0 分 0 秒之间以毫秒为单位的时间差。

Date date = new Date();
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String format1 = sdf1.format(date);
System.out.println(format1);//2019-02-18 11:48:27
//解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),否则，抛异常
Date date2 = sdf1.parse("2020-02-18 11:48:27");
System.out.println(date2);

java.util.Calendar (日历) 类
一个 Calendar Calendar Calendar 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)

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

Date 中的年是从 1900 开始，月是从 0 开始

LocalDateTime localDateTime = LocalDateTime.now();
//        本地化相关的格式。如：ofLocalizedDateTime()
//        FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
        //待解，使用FormatStyle.LONG会报错：java.time.DateTimeException: Unable to extract ZoneId from temporal 2019-11-13T22:26:01.022268700
//        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);

DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL, FormatStyle.MEDIUM);
String str2 = formatter1.format(localDateTime);
System.out.println(str2);

ZonedDateTime zonedDateTime= ZonedDateTime.now();
String str2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG).withLocale(Locale.CHINA).format(zonedDateTime);
System.out.println(str2);

 

Arrays.sort()

Collections.sort()

String str1 = "abc";
String str2 = "IloveU";
System.out.println(str1.compareTo(str2));

 

BigInteger 是不可变的任意精度整数
BigDecimal 是不可变的任意精度有符号浮点型数

13、Java的集合

13、Java的集合

数组和集合的区别：

1、数组的长度是固定的，集合的长度是可变的

2、数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象，而且对象的类型可以不一致。

 

Collection：所以单列集合的父接口，定义了单列集合通用的一些方法

示例代码：

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("读者A");
        boolean b2=coll.add("读者B");
        System.out.println(coll);

        boolean b3=coll.remove("读者C");
        boolean b4=coll.remove("读者B");
        boolean b5=coll.contains("读者A");
        boolean b6=coll.isEmpty();
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        System.out.println(b6);
        System.out.println(coll.size());
        System.out.println(coll.toArray()[0]);

    }
}

iterator ：迭代器接口，迭代，就是collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续判断，如果还有就再取出来，一直到集合中的所有元素都取出。

示例代码：

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("读者A");
        boolean b2=coll.add("读者B");
        Iterator<String> it = coll.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

增强for循环：底层使用迭代器，使用for循环的格式，简化迭代器书写，用来遍历集合和数组

格式 ： for（集合/数组的数据类型 变量名 ： 集合名/数组名）{方法体}

示例代码：

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("读者A");
        boolean b2=coll.add("读者B");
        for (String str:coll) {
            System.out.println(str);
        }
    }
}

注意：增强for循环的目标只能是集合或者数组

 

泛型：是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型 E e :Element 元素 ，T t :Type 类型

 

创建集合，不使用泛型：

好处：集合不使用泛型，默认类型就是Object类型，可以存储任意类型的数据

坏处：不安全，容易引发异常

创建集合，使用泛型：

好处：1、避免了类型转换的麻烦，存储的是什么数据，取出的就是什么类型

         2、把运行期间的异常提升到了编译期间

坏处：泛型是什么类型，只能存储什么类型的数据

 

定义一个泛型的类：修饰符 class 类名<代表泛型的变量>{}

定义一个泛型的方法： 修饰符 <泛型> 返回值类型 方法名 （参数列表（使用泛型））{方法体}，含有泛型的方法在调用方法的时候确定泛型的数据类型，参数传递什么类型，泛型就是什么类型

定义一个泛型的接口： 修饰符 interface 接口名<泛型>{}

含义泛型的接口的使用方式：1、定义接口的实现类，实行接口，指定接口的泛型

                                       2、接口使用什么泛型，实现类就使用什么泛型

 

泛型通配符：当使用泛型类或者接口时，传递的数据中，泛型的类型不确定，可以通过通配符<?>表示。但是一旦使用了泛型通配符后，只能使用Object类中的共性方法，集合中的元素自身方法无法使用

示例代码

public class Demo {
    public static void main(String[] args){}
    
    private class Demo2<E>{
        private E name;

        public E getName() {
            return name;
        }

        public void setName(E name) {
            this.name = name;
        }
        
        public <M> void method(M m){
            
        }
        
        public void printArray(ArrayList<?> list){
            Iterator<?>it = list.iterator();
            while (it.hasNext()){
                System.out.println(it.next());
            }
        }
    }
}

List接口：1、他是一个元素存取有序的集合

              2、他是一个带有索引的集合

              3、集合中可以有重复的元素

注意：要防止索引的越界异常

示例代码

public class Demo {
    public static void main(String[] args){
        List<String> list =new ArrayList<>();
        list.add("读者A");
        list.add("读者B");
        list.add("读者A");
        System.out.println(list);
        list.add(1,"读者C");
        System.out.println(list);
        list.remove(1);
        System.out.println(list);
        list.set(1,"读者D");
        System.out.println(list);
    }
}

ArrayList：前面已经用过，不再讲述，底层是数组数据结构

LinkedList：链表数据结构

示例代码

public class Demo {
    public static void main(String[] args){
       LinkedList<String> list = new LinkedList<>();
       list.add("读者A");
       list.add("读者B");
       list.add("读者A");
        System.out.println(list);
       list.addFirst("读者C");
        System.out.println(list);
        list.addLast("读者D");
        System.out.println(list);
        list.push("读者E");
        System.out.println(list);
        list.pop();
        System.out.println(list);
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        list.removeFirst();
        list.removeLast();
    }
}

Vector：底层是数组数据结构，现在多用ArrayList代替使用

 

Set接口类：1、不允许存储重复的元素

                2、没有索引，没有带索引的方法，也不能使用普通的for循环遍历

 

HashSet实现类：1、不允许存储重复的元素

                        2、没有索引，没有带索引的方法，也不能使用普通的for循环遍历

                        3、是一个无序的集合，存储元素和取出元素的顺序有可能不一致

                        4、底层是一个哈希表结构（查询的速度非常的快）

示例代码：

public class Demo {
    public static void main(String[] args){
       Set<Integer> set = new HashSet<>();
       set.add(96);
       set.add(97);
       set.add(98);
       set.add(99);
       set.add(100);
       set.add(97);
        System.out.println(set);
       Iterator it = set.iterator();
       while (it.hasNext()){
           System.out.println(it.next());
       }
    }
}

扩展：哈希值，是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是数据实际存储的物理地址）

注意：使用HashSet存储自定义类型的元素时，要重写hashCode和equals方法

 

LinkedHashSet:HashSet的子类，元素不可以重复，但是有序，底层是一个哈希表+链表

示例代码：

public class Demo {
    public static void main(String[] args){
       LinkedHashSet<Integer> set = new LinkedHashSet<>();
       set.add(96);
       set.add(97);
       set.add(98);
       set.add(99);
       set.add(97);
        System.out.println(set);
        Iterator it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

 可变参数：当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数 ， 修饰符 返回值类型 方法名（数据类型...变量名）{},可变参数底层就是一个数组，根据传递的参数个数不同，会创建不同长度的数组，来存储这些参数。

public class Demo {
    public static void main(String[] args){
        System.out.println(sum(1,2,3));
        System.out.println(sum(1,2));
    }

    public static int sum (int...a){
        int sum =0;
        for (int b:a) {
            sum+=b;
        }
        return sum;
    }
}

Collections：操作集合的工具类，对集合进行操作

示例代码：

public class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(96);
        list.add(97);
        list.add(98);
        list.add(99);
        list.add(100);
        Collections.shuffle(list);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }
}

Map集合接口：1、Map集合是一个双列集合，一个元素包含两个值（Key，Value）

               2、Map集合中的元素，Key和Value的数据类型可以相同也可以不同

               3、Map集合中的元素，Key是不允许重复的，Value是可以重复的

               4、Map集合中的元素，Key和Value是一一对应的

HashMap<K,V>，Map接口的实现类：1、底层是哈希表，查询速度快

                                                    2、是一个无序的集合，存储元素和取出元素的顺序不一致

LinkedHashMap<K,V>，HashMap的子类：1、底层是哈希表+链表

                                                           2、集合是一个有序的集合，存储元素和取出元素的顺序一致

Map接口的示例代码

public class Demo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("读者A","作品A");
        map.put("读者B","作品B");
        map.put("读者C","作品C");
        map.put("读者D","作品D");
        System.out.println(map);
        map.remove("读者D");
        System.out.println(map);
        System.out.println(map.get("读者A"));
        System.out.println(map.containsKey("读者A"));

        Set<String> set =map.keySet();
        Iterator<String> it1 = set.iterator();
        while(it1.hasNext()){
            String str = it1.next();
            System.out.println(map.get(str));
        }

        Set<Map.Entry<String,String >> set2 = map.entrySet();
        Iterator<Map.Entry<String ,String >> it2 = set2.iterator();
        while (it2.hasNext()){
            Map.Entry<String ,String > entry = it2.next();
            System.out.println(entry.getKey()+"="+entry.getValue());
        }




    }
}

关于13、java——常用类和java 常用类的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于10、Java—— 内部类、12、Java——异常、13_Java 常用类、13、Java的集合等相关内容，可以在本站寻找。

本文标签：

上一篇java基础——随机访问流（java随机访问文件功能）

下一篇Java16周作业（java小作业）

相关文章