JAVA扩展包安卓 java 扩展

转载

棉花糖 2023-09-19 07:53:20

文章标签 JAVA扩展包安卓 java 开发语言 jvm System 文章分类 Java 后端开发

Java拓展

文章目录

Java拓展
相关

1、Collection接口

1.1接口中的相关方法

一、集合

Set（List、Set都是继承自Collection接口）
List
Map

二、常用类

Object

1、简介
2、主要方法

String

1、简介
2、创建字符串
3、字符、字节与字符串的转换
4、字符串内容比较
5、字符串查找
6、字符串替换
7、字符串拆分
8、字符串截取
主要方法

StringBuilder

1、简介
2、主要方法

StringBuffer

1、简介
2、主要方法

System

1、简介
2、主要方法

Data

1、简介
2、主要方法

构造方法
常用方法

描述对应类的作用、找出类的重要方法，带有必要的文字说明和部分代码演示

一、集合

在Java中，如果一个Java对象可以在内部持有若干其他Java对象，并对外提供访问接口，我们把这种Java对象称为集合。很显然，Java的数组可以看作是一种集合：

String[] ss = new String[10]; // 可以持有10个String对象
ss[0] = "Hello"; // 可以放入String对象
String first = ss[0]; // 可以获取String对象

Java集合主要由两个接口派生而来：Collection和Map，大致分为四个体系：

Set（List、Set都是继承自Collection接口）

1、简介

存储和取出的顺序不一致可以把多个对象存放入Set集合内，在集合内是无法记住元素的添加顺序
元素唯一 Set不允许包含重复元素，常用的方法有HashSet、TreeSet、LinkedHashSet等，添加同一对象两次到集合中，第二次会操作失败add返回false，添加相同的元素值的两个对象也是如此
不可以根据索引获取元素 Set实际上相当于只存储key、不存储value的Map。
我们经常用Set用于去除重复元素。

2、主要的方法

将元素添加进Set< E>： add(E e)
将元素从Set< E>删除： remove(Object e)
判断是否包含元素： contains(Object e)

import java.util.*;
public class N1 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        System.out.println(set.add("abc")); // true
        System.out.println(set.add("xyz")); // true
        System.out.println(set.add("xyz")); // false，添加失败，因为元素已存在
        System.out.println(set.contains("xyz")); // true，元素存在
        System.out.println(set.contains("XYZ")); // false，元素不存在
        System.out.println(set.remove("hello")); // false，删除失败，因为元素不存在
        System.out.println(set.size()); // 2，一共两个元素
    }
}

/*
输出结果
true
true
false
true
false
false
2
*/

3、HashSet

import java.util.*;
 
public class Test{
    public static void main(String[] args){
 
        //1. 创建个可存储任意类型的HashSet集合：set1
        HashSet set1 = new HashSet();  //相当于HashSet<Object> set1 = new HashSet(); 
        //给set1添加一些元素
        set1.add('a');
        set1.add(10);
        set1.add("str");
        set1.add(true);
 
 
        //2. 创建个只能存储String类型的HashSet集合：set2
        HashSet<String> set2 = new HashSet();
        //向set2中添加一些元素
        set2.add("hello");
        set2.add("nice");
 
 
        //3. 创建个TreeSet集合：set3
        TreeSet set3 = new TreeSet();
        //向set3中添加一些元素
        set3.add(1); //确定了只能添加整型类型元素
        set3.add(2);
 
        
    }
}

public class HashSetTest {
    public static void main(String[] agrs){
        //创建HashSet集合：
        Set<String> hashSet = new HashSet<String>();
        System.out.println("HashSet初始容量大小："+hashSet.size());
 
        //元素添加：
        hashSet.add("my");
        hashSet.add("name");
        hashSet.add("is");
        hashSet.add("jiaboyan");
        hashSet.add(",");
        hashSet.add("hello");
        hashSet.add("world");
        hashSet.add("!");
        System.out.println("HashSet容量大小："+hashSet.size());
 
        //迭代器遍历：
        Iterator<String> iterator = hashSet.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }
        //增强for循环
        for(String str:hashSet){
            if("jiaboyan".equals(str)){
                System.out.println("你就是我想要的元素:"+str);
            }
            System.out.println(str);
        }
 
        //元素删除：
        hashSet.remove("jiaboyan");
        System.out.println("HashSet元素大小：" + hashSet.size());
        hashSet.clear();
        System.out.println("HashSet元素大小：" + hashSet.size());
 
        //集合判断：
        boolean isEmpty = hashSet.isEmpty();
        System.out.println("HashSet是否为空：" + isEmpty);
        boolean isContains = hashSet.contains("hello");
        System.out.println("HashSet是否为空：" + isContains);
    }
}

List

1、简介

有序、可重复（主要有ArrayList、LinkedList、Vector）。
List的行为和数组几乎完全相同：List内部按照放入元素的先后顺序存放
每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始

2、主要方法

向集合中添加内容：add(Object)、add(Index,Object)

List list=new ArrayList();
list.add("test");
System.out.println(list);
/*
运行结果，[test]
*/

修改集合内容：提供下标和内容，修改对应位置的数据

List list=new ArrayList();
list.add("test");
list.set(0,"hi");
System.out.println(list);
/*
运行结果：[hi]

3、ArrayList、LinkedList、Vector

ArrayList：底层数据结构是数组
LinkedList：底层数据结构是链表
Vector：底层数据结构是数组

Map

1、简介

有映射关系的集合（主要有HashTable、HashMap、TreeMap、LinkedHashMap）
Map<K, V>是一种键-值映射表,不保证顺序,遍历的顺序既不一定是put()时放入的key的顺序，也不一定是key的排序顺序
Map中不存在重复的key，因为放入相同的key，只会把原有的key-value对应的value给替换掉
在一个Map中，虽然key不能重复，但value是可以重复的

Map<String, Integer> map = new HashMap<>();
map.put("apple", 123);
map.put("pear", 123); // ok

2、主要方法

put(K key, V value)方法：把key和value做了映射并放入Map
V get(K key)方法：通过key获取到对应的value
boolean containsKey(K key)方法：查询某个key是否存在

import java.util.HashMap;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 123);
        map.put("pear", 456);
        System.out.println(map.get("apple")); // 123
        map.put("apple", 789); // 再次放入apple作为key，但value变为789
        System.out.println(map.get("apple")); // 789
    }
}

二、常用类

Object

1、简介

它为超类、基类，位于继承数的最顶层，是所有类的直接或间接父类
任何类只要没有声明 extends 显示继承某个类，那么都会默认继承 Object 类，否则间接继承 Object 类
Object 类中所定义的方法，是所有对象都具备的方法，所以子类可以使用 Object 的所有方法

2、主要方法

1、 getClass 方法:

类型：Class<?>
返回引用中储存的实际对象类型
通常用于判断两个引用中实际存储对象类型是否一致

public final native Class<?> getClass();

public class TestStudent {
    public static void main(String[] args) {

        Student s1 = new Student("lisa",20);
        Student s2 = new Student("kirot", 21);

        //判断s1和s2是不是同个类型：getClass();
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();

        System.out.println(class1 == class2 ? "s1和s2属于同个类型" : "s1和s2不属于同个类型");

    }
}

/*
运行结果：s1和s2属于同个类型
*/

final 方法、获取对象的运行时 class 对象，class 对象就是描述对象所属类的对象。这个方法通常是和 Java 反射机制搭配使用的。

2、hashCode 方法:

类型：int
该方法主要用于获取对象的散列值，返回该对象的哈希码值。Object 中该方法默认返回的是对象的堆内存地址。
一般情况下相同的对象返回相同的哈希码值

public native int hashCode();

public class TestStudent {
    public static void main(String[] args) {

        Student s1 = new Student("lisa",20);
        Student s2 = new Student("kirot", 21);

        //返回s1和s2的哈希码值，不同对象返回的哈希码不一样
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        Student s3 = s1;
        //s1地址赋给了s3，所以它们的哈希码值是一样的
        System.out.println(s3.hashCode());

    }
}
/*
运行结果：
2129789493
668386784
2129789493
*/

3、equals 方法:

该方法用于比较两个对象，如果这两个对象引用指向的是同一个对象，那么返回 true，否则返回 false。
一般 equals 和 == 是不一样的，但是在 Object 中两者是一样的。
子类一般都要重写这个方法。

public boolean equals(Object obj) { return (this == obj);}

4、clone 方法:

该方法是保护方法，实现对象的浅复制
只有实现了 Cloneable 接口才可以调用该方法，否则抛出 CloneNotSupportedException 异常。

protected native Object clone() throws CloneNotSupportedException;

5、 toString 方法:

类型：String
返回该对象的字符串表示形式，一般子类都有覆盖。默认返回格式如下：对象的 class 名称 + @ + hashCode 的十六进制字符串。

public String toString() {
 return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

public class TestStudent {
    public static void main(String[] args) {

        Student s1 = new Student("lisa",20);
        Student s2 = new Student("kirot", 21);

        //返回对象字符串表示形式：类的名字 + @ + 十六进制的哈希码值
        System.out.println(s1.toString());
        System.out.println(s2.toString());

    }
}
/*
运行结果：Student@7ef20235
         Student@27d6c5e0
   */      
//还可以通过在类中重写 toString() 方法，返回自己自定义的字符串

6、 notify 方法

public final native void notify();
//final 方法，主要用于唤醒在该对象上等待的某个线程

7、 notifyAll 方法
8、 wait(long timeout) 方法

timeout：最大等待时间（毫秒）

String

1、简介

String类位于java.lang包下，是Java语言的核心类，提供了字符串的比较、查找、截取、大小写转换等操作
String类不能被继承，并且它的成员方法都默认为final方法；字符串一旦创建就不能再修改。

2、创建字符串

String str = "Hello Bit";// 方式一
String str2 = new String("Hello Bit");// 方式二
char[] array = { 'a', 'b', 'c'};String str3 = new String(array);// 方式三

3、字符、字节与字符串的转换

（1）字符与字符串的转换

字符串等同于是一个个字符的集合，因此要想字符转为字符串则要调用String的构造方法并传入一个字符数组。

char[] val = { 'a','b','c'};
String str = new String(val);
System.out.println(str);

可以选择字符数组从哪个下标开始到哪个下标结束的字符转换为字符串的形式。

char[] val = { 'a','b','c','d','e'};
String str1 = new String(val,0,3);
System.out.println(str1);//打印结果为abc
String str2 = new String(val,1,3);
System.out.println(str2);//打印结果为bcd

如果字符串要转换为单个字符，代码如下：

String str = "abc";
System.out.println(str.charAt(1));//打印结果为b

如果字符串要转换为字符数组，代码如下：

String str = "abc";
char[] val = str.toCharArray();
System.out.println(Arrays.toString(val));//打印结果：[a, b, c]

（2）、字节与字符串的转换

字节数组转换为字符串：

byte[] bytes = { 97,98,99，100};
String str1 = new String(bytes,0,3);
System.out.println(str1);//打印结果为abc
System.out.println("========");
String str2 = new String(bytes,1,3);
System.out.println(str2);打印结果为bcd

字符串转换为字节数组

String str1 = "abc";
byte[] bytes1 = str1.getBytes();
System.out.println(Arrays.toString(bytes1));打印结果为：[97, 98, 99]//

4、字符串内容比较

对于字符串比较，我们不能直接用“==”，而有三种方法能够对字符串有不同的比较方式。

比较字符串内容：直接调用String类的equals方法,将字符串放入括号当中比较。
比较字符串内容（不分字母大小写）：调用String类的equalsIgnoreCase方法

String str1 = "hello" ;
String str2 = "Hello" ; System.out.println(str1.equals(str2)); // false 
System.out.println(str1.equalsIgnoreCase(str2); 
// true

比较字符串中的大小：调用String类当中的compareTo方法。(本来String类当中是没有compareTo方法，只不过String类实现了Comparable接口，并且重写了compareTo方法。)它是一个字符一个字符进行比较的。如果str1大于str2则返回str1该字符减去str2该字符的值

String str1 = "abc";
String str2 = "bcd";
System.out.println(str1.compareTo(str2));//运行结果为：-1
/*因为b的ASCII码值比a的ASCII码值大1，
则直接返回-1。（如果是字符不相同则返回它们的ASCII码差值）*/

5、字符串查找

判断一个子串是否存在于主串中：调用String类的contains方法，返回值为boolean。

String str = "abbabcacc";
boolean flg = str.contains("abc");
System.out.println(flg);//打印结果为true

从头开始查找一个子串，并返回第一个子串开始的索引位置，如果没有，则返回-1。也可以传入一个索引，代表是从哪个索引位置开始寻找，调用String类中的indexOf方法。

String str = "abbabcacc";
int index = str.indexOf("abc");
System.out.println(index);//打印结果为3

6、字符串替换

替换字符串中的所有的指定内容。调用String类当中的repalceAll方法

String str = "helloworld" ; 
System.out.println(str.replaceAll("l", "_"));//打印结果为he__owor_d

也可以选择替换字符串中的首个内容。调用String类中的repalceFirst方法。

String str = "helloworld" ;
System.out.println(str.replaceFirst("l", "_"));
//打印结果为he_loworld

7、字符串拆分

指定字符串在主串的基础上能分为几个组就等于分为几个String类数组。因此可以通过foreach循环来遍历拆分后的数组的内容。调用String类的split方法。

String str = "hello world hello bit" ; 
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) { 
    System.out.println(s);
     }   //打印结果为helloworldhellobit

8、字符串截取

对于一个字符串的截取，传入一个索引值代表是从哪个索引开始截取。传入两个索引值则代表截取的范围。调用String类中的substring方法。

String str = "helloworld" ;
System.out.println(str.substring(5));
System.out.println(str.substring(0, 5));//打印结果为worldhello

索引从0开始
注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

主要方法

1、 length()

返回字符串中的字符数。

2、 equals(s1)

如果该字符串内容等于字符串s1，返回true。

b1.equals(b2) //返回false

3、 compareTo(s1)

返回一个大于零、等于零、小于零的整数，表明一个字符串是否大于、等于、或小于s1

s1="abc";
s2 ="abg";
s1compareTo(s2)//返回-4

4、 substring(beginIndex)

返回字符串，从特定位置beginindex开始到字符串结尾
5、 substring(beginindex,endIndex)
返回字符串从从下标beginIndex到beginIndex-1的下标位置
6、 indexOf(ch)
返回字符串中出现第一个ch的下标，如果没有返回-1

"Welcome to Java".indexOf(‘W’)//返回 0

注意区别：String是常量，是不可变的。当拼接时，Java会在编译期间将String类的对象拼接优化为StringBuffer的拼接（不会产生新对象），因此Java中有StringBuffer和StringBuilder中处理字符串，并且它们拼接时不会产生新的对象，而是在原来的字符串基础上拼接。

StringBuilder

1、简介

StringBuilder表面看起来是用来拼接、处理字符串的一个工具类，但它的内部实现其实是处理字符序列。

2、主要方法

序号	方法描述
1	public StringBuilder append(String s)：将指定的字符串追加到此字符序列。
2	public StringBuilder reverse()：将此字符序列用其反转形式取代。
3	public delete(int start, int end)：移除此序列的子字符串中的字符。
4	public insert(int offset, int i)：将 int 参数的字符串表示形式插入此序列中。
5	insert(int offset, String str)：将 str 参数的字符串插入此序列中。
6	replace(int start, int end, String str):使用给定 String 中的字符替换此序列的子字符串中的字符。

1、 append(XXX xxx)

StringBuilder sb = new StringBuilder();
        sb.append(8).append("乘以").append(6.6).append('=').append(true);
        sb.append(new StringBuilder("!!!"));
        System.out.println(sb); // 输出结果为：8乘以6.6=true!!!

2、reverse()

StringBuilder sb = new StringBuilder("猪头大一来过上海");
        sb.reverse();
        System.out.println(sb); // 输出结果为：海上过来一大头猪

3、replace(int start, int end, String str)

StringBuilder sb = new StringBuilder("春眠不觉晓，处处闻啼鸟。");
        sb.replace(8, 11, "蚊子咬");
        System.out.println(sb); // 输出结果为：春眠不觉晓，处处蚊子咬。

4、 delete(int start, int end)

StringBuilder sb = new StringBuilder("爸爸的脸蛋有很多褶皱");
        sb.delete(3, 4);
        System.out.println(sb); // 输出结果为：爸爸的蛋有很多褶皱

5、insert(int offset, XXX xxx)

StringBuilder sb = new StringBuilder("《摔跤吧！爸爸》");
        sb.insert(3, "了");
        System.out.println(sb); // 输出结果为：《摔跤了吧！爸爸》

StringBuffer

1、简介

当一个字符串的内容需要被经常改变时就要使用StringBuffer。
StringBuffer又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。StringBuffer是个字符串的缓冲区，它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。

2、主要方法

创建一个字符串缓冲区对象。用于存储数据。

StringBuffer sb = new StringBuffer();

sb.append("haha"); //添加字符串

sb.insert(2, "it");//在指定位置插入

sb.delete(1, 4);//删除

sb.replace(1, 4, "cast");//替换指定范围内的内容

 String str = sb.toString();
 /*String变为StringBuffer:利用StringBuffer的构造方法或append()方法。
StringBuffer变为String:调用toString()方法。
*/

注意：

append、delete、insert、replace、reverse方法调用后，返回值都是当前对象自己，所以说，StringBuffer它可以改变字符序列的长度和内容。
在大多数实现中，StringBuilder比 StringBuffer 要快。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
多数情况下推荐使用StringBuilder 类

System

1、简介

System类的构造器由private修饰，不允许被实例化。因此，类中的方法也都是static修饰的静态方法。属于java.lang包下面的类。
System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)

2、主要方法

1、 currentTimeMillis()

获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

2、exit(int status)

用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态

3、 gc()

用来运行JVM中的垃圾回收器，完成内存中垃圾的清除。

4、 getProperty(String key)

用来获取指定键(字符串名称)中所记录的系统属性信息
5、 arraycopy方法
用来实现将源数组部分元素复制到目标数组的指定位置，复制数组，性能比循环好

int[] a = {1,2,3,4};
int[] b = new int[5];
//参数分别是:被复制对象;从下标为0的开始;目标对象;从下标为0的开始给值;总共复制3个数

System.arraycopy(a, 0, b, 0, 3);
for (inti : b) {
    System.out.print(i);
}    //12300

Data

1、简介

在Java中获取当前时间，可以使用 java.util.Date 类完成.
Date 类主要封装了系统的日期和时间的信息
Date 类表示系统特定的时间戳，可以精确到毫秒。
Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。

2、主要方法

构造方法

1、 Date()

此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。
2、 Date(long date)
此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数。

Date date1 = new Date();    // 调用无参数构造函数
System.out.println(date1.toString());    
Date date2 = new Date(60000);    // 调用含有一个long类型参数的构造函数
System.out.println(date2);    // 输出

常用方法

1、 boolean after(Date when)

判断此日期是否在指定日期之后
2、 boolean before(Date when)
判断此日期是否在指定日期之前
3、 int compareTo(Date anotherDate)
比较两个日期的顺序
4、 boolean equals(Object obj)
比较两个日期的相等性
5、 long getTime()
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来，此 Date 对象表示的毫秒数
6、 String toString()
把此 Date 对象转换为以下形式的 String: dow mon dd hh:mm:ss zzz yyyy。
其中 dow 是一周中的某一天(Sun、Mon、Tue、Wed、Thu、Fri 及 Sat)

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：java回调机制结构图 jni回调java

下一篇：ios开发性能优化 ios 性能优化

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯