Java Math 类

xxxValue() 方法用于将 Number 对象转换为 xxx 数据类型的值并返回。

Java 常用类和方法

Java equals() 方法

equals() 方法用于判断 Number 对象与方法的参数进是否相等。例：

public class Test{
        public static void main(String args[]){
                Integer x = 5;
                Integer y = 10;
                Integer z =5;
                Short a = 5;

                System.out.println(x.equals(y));  
                System.out.println(x.equals(z));
                System.out.println(x.equals(a));
        }
}

结果：

false
true
false

Java valueOf() 方法

数值类型转换

valueOf() 方法用于返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等。

该方法是静态方法。该方法可以接收两个参数一个是字符串，一个是基数。

语法

该方法有以下几种语法格式：

static Integer valueOf(int i)
static Integer valueOf(String s)
static Integer valueOf(String s, int radix)

参数

i — Integer 对象的整数。
s — Integer 对象的字符串。
radix –在解析字符串 s 时使用的进制数，用于指定使用的进制数。

返回值

Integer valueOf(int i)：返回一个表示指定的 int 值的 Integer 实例。
Integer valueOf(String s):返回保存指定的 String 的值的 Integer 对象。
Integer valueOf(String s, int radix): 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。

public class Test{
public static void main(String args[]){
                Integer x =Integer.valueOf(9);
                Double c = Double.valueOf(5);
                Float a = Float.valueOf("80");              

                Integer b = Integer.valueOf("444",16);   // 使用 16 进制

                System.out.println(x);
                System.out.println(c);
                System.out.println(a);
                System.out.println(b);
        }
}

结果：

Java toString() 方法

整数转化为字符串

toString() 方法用于返回以一个字符串表示的 Number 对象值。

public class Test{
    public static void main(String args[]){
        Integer x = 5;

        System.out.println(x.toString());  
        System.out.println(Integer.toString(12)); 
    }
}

结果：

5
12

Java parseInt() 方法

字符串转int类型

parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析。

语法

所有 Number 派生类 parseInt 方法格式类似如下：

static int parseInt(String s)

static int parseInt(String s, int radix)

参数

s — 十进制表示的字符串。
radix — 指定的基数。

返回值

parseInt(String s): 返回用十进制参数表示的整数值。
parseInt(int i): 使用指定基数的字符串参数表示的整数 (基数可以是 10, 2, 8, 或 16 等进制数) 。

public class Test{
    public static void main(String args[]){
        int x =Integer.parseInt("9");
        double c = Double.parseDouble("5");
        int b = Integer.parseInt("444",16);

        System.out.println(x);
        System.out.println(c);
        System.out.println(b);
    }
}

结果：

9
5.0
1092

Java abs() 方法

返回绝对值

public class Test{
    public static void main(String args[]){
        Integer a = -8;
        double d = -100;
        float f = -90f;    
                                               
        System.out.println(Math.abs(a));
        System.out.println(Math.abs(d));    
        System.out.println(Math.abs(f));    
    }
}

结果：

8
100.0
90.0

Java round() 方法

round() 方法返回一个最接近的 int、long 型值，四舍五入。

round 表示”四舍五入“，算法为Math.floor(x+0.5) ，即将原来的数字加上 0.5 后再向下取整，所以 Math.round(11.5) 的结果为 12，Math.round(-11.5) 的结果为 -11。

public class Test{
    public static void main(String args[]){
        double d = 100.675;
        double e = 100.500;
        float f = 100;
        float g = 90f;
 
        System.out.println(Math.round(d));
        System.out.println(Math.round(e)); 
        System.out.println(Math.round(f)); 
        System.out.println(Math.round(g)); 
    }
}

结果：

Java min() 方法

min() 方法用于返回两个参数中的最小值。

Java max() 方法

max() 方法用于返回两个参数中的最大值。

Java pow() 方法

计算n次方

pow() 方法用于返回第一个参数的第二个参数次方。

public class Test{
    public static void main(String args[]){
        double x = 11.635;
        double y = 2.76;

        System.out.printf("e 的值为 %.4f%n", Math.E);
        System.out.printf("pow(%.3f, %.3f) 为 %.3f%n", x, y, Math.pow(x, y));
    }
}

结果：

18.456
23.12

Java sqrt() 方法

求算数平方根

sqrt() 方法用于返回参数的算术平方根。

Java random() 方法

返回随机数

random() 方法用于返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0。

这是一个默认方法，不接受任何参数。

public class Test{
    public static void main(String args[]){
        System.out.println( Math.random() );
        System.out.println( Math.random() );
    }
}

结果：

0.5444085967267008
0.7960235983184115

Java Character 类

Java isLetter() 方法

判断字符是否是字母

isLetter() 方法用于判断指定字符是否为字母。

public class Test {

    public static void main(String args[]) {
        System.out.println(Character.isLetter('c'));
        System.out.println(Character.isLetter('5'));
    }
}

结果：

true
false

Java isDigit() 方法

判断字符是否为数字

isDigit() 方法用于判断指定字符是否为数字。

public class Test {

    public static void main(String args[]) {
        System.out.println(Character.isDigit('c'));
        System.out.println(Character.isDigit('5'));
    }
}

结果：

false
true

Java isUpperCase() 方法

判断字符是否是大写字母

isUpperCase() 方法用于判断指定字符是否为大写字母。

public class Test {

    public static void main(String args[]) {
        System.out.println( Character.isUpperCase('c'));
        System.out.println( Character.isUpperCase('C'));
    }
}

结果：

false
true

Java isLowerCase() 方法

判断字符是否是小写字母

isLowerCase() 方法用于判断指定字符是否为小写字母。

public class Test {

    public static void main(String args[]) {
        System.out.println( Character.isLowerCase('c'));
        System.out.println( Character.isLowerCase('C'));
    }
}

结果：

true
false

Java toUpperCase() 方法

转大写字母

toUpperCase() 方法用于将小写字符转换为大写。

public class Test {

    public static void main(String args[]) {
        System.out.println(Character.toUpperCase('a'));
        System.out.println(Character.toUpperCase('A'));
    }
}

结果：

A
A

Java toLowerCase() 方法

转小写字母

toLowerCase() 方法用于将大写字符转换为小写。

public class Test {

    public static void main(String args[]) {
        System.out.println(Character.toLowerCase('a'));
        System.out.println(Character.toLowerCase('A'));
    }
}

结果：

a
a

Java String 类

Java charAt() 方法

返回指定索引处的字符

charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() – 1。

public class Test {
    public static void main(String args[]) {
        String s = "www.runoob.com";
        char result = s.charAt(6);
        System.out.println(result);
    }
}

结果：

Java String equals() 方法

判断字符串是否相等

String 类中重写了 equals() 方法用于比较两个字符串的内容是否相等。

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("runoob");
        String Str2 = Str1;
        String Str3 = new String("runoob");
        boolean retVal;

        retVal = Str1.equals( Str2 );
        System.out.println("返回值 = " + retVal );

        retVal = Str1.equals( Str3 );
        System.out.println("返回值 = " + retVal );
    }
}

结果：

返回值 = true
返回值 = true

Java startsWith() 方法

startsWith() 方法用于检测字符串是否以指定的前缀开始。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.runoob.com");
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("www") );
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("runoob") );
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("runoob", 4) );
    }
}

结果：

返回值 :true
返回值 :false
返回值 :true

Java endsWith() 方法

endsWith() 方法用于测试字符串是否以指定的后缀结束。

public class Test {
    public static void main(String args[]) {
        String Str = new String("菜鸟教程：www.runoob.com");
        boolean retVal;
 
        retVal = Str.endsWith( "runoob" );
        System.out.println("返回值 = " + retVal );
 
        retVal = Str.endsWith( "com" );
        System.out.println("返回值 = " + retVal );
    }
}

返回值 = false
返回值 = true

Java String indexOf() 方法

返回字符、字符串在给定的字符串中第一次出现的索引

public class Main {
    public static void main(String args[]) {
        String string = "aaa456ac";  
        //查找指定字符是在字符串中的下标。在则返回所在字符串下标；不在则返回-1.  
        System.out.println(string.indexOf("b")); // indexOf(String str); 返回结果：-1，"b"不存在  
 
        // 从第四个字符位置开始往后继续查找，包含当前位置  
        System.out.println(string.indexOf("a",3));//indexOf(String str, int fromIndex); 返回结果：6  
 
        //（与之前的差别：上面的参数是 String 类型，下面的参数是 int 类型）参考数据：a-97,b-98,c-99  
 
        // 从头开始查找是否存在指定的字符  
        System.out.println(string.indexOf(99));//indexOf(int ch)；返回结果：7  
        System.out.println(string.indexOf('c'));//indexOf(int ch)；返回结果：7  
 
        //从fromIndex查找ch，这个是字符型变量，不是字符串。字符a对应的数字就是97。  
        System.out.println(string.indexOf(97,3));//indexOf(int ch, int fromIndex); 返回结果：6  
        System.out.println(string.indexOf('a',3));//indexOf(int ch, int fromIndex); 返回结果：6  
    }
}

结果：

Java String length() 方法

返回字符串长度

public class Test {
        public static void main(String args[]) {
                String Str1 = new String("www.runoob.com");
                String Str2 = new String("runoob" );

                System.out.print("字符串 Str1 长度 :");
                System.out.println(Str1.length());
                System.out.print("字符串 Str2 长度 :");
                System.out.println(Str2.length());
        }
}

结果：

字符串 Str1 长度 :14
字符串 Str2 长度 :6

Java replace() 方法

替换字符串

replace() 方法通过用 newChar 字符替换字符串中出现的所有 searchChar 字符，并返回替换后的新字符串。

public class Main {
    public static void main(String args[]) {
        String Str = new String("Runoob");

        System.out.print("返回值 :" );
        System.out.println(Str.replace('o', 'T'));

        System.out.print("返回值 :" );
        System.out.println(Str.replace('u', 'D'));
    }
}

结果：

返回值 :RunTTb
返回值 :RDnoob

Java split() 方法

字符串分割

split() 方法根据匹配给定的正则表达式来拆分字符串。

注意： . 、 $、 | 和 * 等转义字符，必须得加 //。

注意：多个分隔符，可以用 | 作为连字符。

public class Test {
    public static void main(String args[]) {
        String str = new String("Welcome-to-Runoob");
 
        System.out.println("- 分隔符返回值 :" );
        for (String retval: str.split("-")){
            System.out.println(retval);
        }
 
        System.out.println("");
        System.out.println("- 分隔符设置分割份数返回值 :" );
        for (String retval: str.split("-", 2)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str2 = new String("www.runoob.com");
        System.out.println("转义字符返回值 :" );
        for (String retval: str2.split("//.", 3)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str3 = new String("acount=? and uu =? or n=?");
        System.out.println("多个分隔符返回值 :" );
        for (String retval: str3.split("and|or")){
            System.out.println(retval);
        }
    }
}

结果：

- 分隔符返回值 :
Welcome
to
Runoob

- 分隔符设置分割份数返回值 :
Welcome
to-Runoob

转义字符返回值 :
www
runoob
com

多个分隔符返回值 :
acount=? 
 uu =? 
 n=?

Java substring() 方法

substring() 方法返回字符串的子字符串。

语法

publicString substring(int beginIndex)或publicString substring(int beginIndex,int endIndex)

参数

beginIndex — 起始索引（包括）, 索引从 0 开始。
endIndex — 结束索引（不包括）。

public class RunoobTest {
    public static void main(String args[]) {
        String Str = new String("This is text");
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4) );
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4, 10) );
    }
}

结果：

返回值 : is text
返回值 : is te

Java toCharArray() 方法

字符串转字符数组

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.runoob.com");
        char[] myChar = Str.toCharArray();
        System.out.println(myChar);
        System.out.println(myChar[1]);
    }
}

结果：

www.runoob.com
w

Java valueOf() 方法

拼接字符为字符串

valueOf() 方法有以下几种不同形式：

valueOf(boolean b): 返回 boolean 参数的字符串表示形式。.
valueOf(char c): 返回 char 参数的字符串表示形式。
valueOf(char[] data): 返回 char 数组参数的字符串表示形式。
valueOf(char[] data, int offset, int count): 返回 char 数组参数的特定子数组的字符串表示形式。
valueOf(double d): 返回 double 参数的字符串表示形式。
valueOf(float f): 返回 float 参数的字符串表示形式。
valueOf(int i): 返回 int 参数的字符串表示形式。
valueOf(long l): 返回 long 参数的字符串表示形式。
valueOf(Object obj): 返回 Object 参数的字符串表示形式。

public class Test {
    public static void main(String args[]) {
        double d = 1100.00;
        boolean b = true;
        long l = 1234567890;
        char[] arr = {'r', 'u', 'n', 'o', 'o', 'b' };

        System.out.println("返回值 : " + String.valueOf(d) );
        System.out.println("返回值 : " + String.valueOf(b) );
        System.out.println("返回值 : " + String.valueOf(l) );
        System.out.println("返回值 : " + String.valueOf(arr) );
    }
}

结果：

返回值 : 1100.0
返回值 : true
返回值 : 1234567890
返回值 : runoob

Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

Java StringBuffer append()方法

字符串追加

public class Test {

   public static void main(String args[]) {
      StringBuffer sb = new StringBuffer("Test");
      sb.append(" String Buffer");
      System.out.println(sb); 
   }  
}

结果：

Test String Buffer

Java StringBuffer reverse()方法

字符串翻转

public class Test {

   public static void main(String args[]) {
      StringBuffer buffer = new StringBuffer("Yiibai Com");
      buffer.reverse();
      System.out.println(buffer);
   }  
}

结果：

moC iabiiY

Java StringBuffer delete()方法

删除字符串中的子序列

Java StringBuffer delete()方法删除此StringBuffer的子字符串中的字符。子字符串从指定的开始处开始并延伸到索引结束处的字符，-1或者如果不存在这样的字符则延伸到StringBuffer的结尾。

如果start等于end，则不进行任何更改。

public class Test {

     public static void main(String args[]) {
          StringBuffer sb = new StringBuffer("Welcom to yiibai.com");
          sb.delete(3, 7); 
          System.out.println(sb); 
       }  
}

结果：

Welto yiibai.com

Java StringBuffer insert()方法

Java StringBuffer insert()方法将数据插入此StringBuffer的子字符串中。应该指定需要在其中插入数据的偏移值(整数类型)。使用该方法，可以插入诸如整数，字符，字符串等各种类型的数据。

如果start等于end，则不进行任何更改。

public class Test {

   public static void main(String args[]) {
      StringBuffer sb = new StringBuffer("Welcome to yiibai.com");
      sb.insert(3, "1234");
      System.out.println(sb); 
   }  
}

结果：

Wel1234come to yiibai.com

Java StringBuffer replace()方法

Java StringBuffer replace()方法将此StringBuffer的子字符串中的字符替换为指定的String字符。

子字符串从指定的开始处开始，如果不存在这样的字符，则扩展到end - 1索引或StringBuffer结束处的字符。首先删除子字符串中的字符，在start处插入指定的字符串。

public class Test {

   public static void main(String args[]) {
      StringBuffer sb = new StringBuffer("abcdefghijk");
      sb.replace(3, 8, "ABCD");
      System.out.println(sb); 
   }  
}

结果：

abcABCDijk

Java ArrayList

Java ArrayList add() 方法

指定位置插入元素，默认在最后面添加

import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        //创建一个数组
        ArrayList<Integer> primeNumbers = new ArrayList<>();
        // 往数组插入元素
        primeNumbers.add(2);
        primeNumbers.add(3);
        primeNumbers.add(5);
        System.out.println("ArrayList: " + primeNumbers);
        primeNumbers.add(1,7);
        System.out.println("ArrayList: " + primeNumbers);
    }
}

结果：

ArrayList: [2, 3, 5]
ArrayList: [2, 7, 3, 5]

Java ArrayList clone() 方法

clone() 方法用于拷贝一份动态数组，属于浅拷贝。

拓展：

浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。。

浅拷贝对应的就是深拷贝，深拷贝是将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象。

Java ArrayList contains() 方法

判断元素是否在数组中存在

import java.util.ArrayList;

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

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 检查 Runoob 是否在这个数组中
        System.out.print("Runoob 是否存在于 arraylist: ");
        System.out.println(sites.contains("Runoob"));

        // 检查 Weibo 是否在这个数组中
        System.out.print("Weibo 是否存在于 arraylist: ");
        System.out.println(sites.contains("Weibo"));
    }
}

结果：

Runoob 是否存在于 arraylist: true
Weibo 是否存在于 arraylist: false

Java ArrayList get() 方法

获取数组中索引位置的元素

import java.util.ArrayList;

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

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 获取在索引值为1处的元素
        String element = sites.get(1);
        System.out.println("索引值为 1 的元素为: " + element);
    }
}

结果：

网站列表: [Google, Runoob, Taobao]
索引值为 1 的元素为: Runoob

Java ArrayList indexOf() 方法

获取数组中指定元素索引，有多个重复元素只返回第一次出现的索引

import java.util.ArrayList;

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

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 查找位置索引值为 Runoob 的元素
        int position1 = sites.indexOf("Runoob");
        System.out.println("Runoob 的索引位置: " + position1);

        // 查找位置索引值为 Weibo 的元素
        int position2 = sites.indexOf("Weibo");
        System.out.println("Weibo 的索引位置: " + position2);
    }
}

结果：

Runoob 的索引位置: 1
Weibo 的索引位置: -1

Java ArrayList remove() 方法

删除数据中的元素

import java.util.ArrayList;

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

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 删除元素 Taobao
        boolean result = sites.remove("Taobao");
        System.out.println("Taoabo 是否被删除? " + result);
        System.out.println("使用 remove() 后: " + sites);

    }
}

结果：

网站列表: [Google, Runoob, Taobao]
Taoabo 是否被删除? true
使用 remove() 后: [Google, Runoob]

删除指定位置元素

import java.util.ArrayList;

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

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 删除位置索引为 2 的元素
        String element = sites.remove(2);
        System.out.println("使用 remove() 后: " + sites);
        System.out.println("移除的元素: " + element);
    }
}

结果：

网站列表: [Google, Runoob, Taobao]
使用 remove() 后: [Google, Runoob]
移除的元素: Taobao

Java ArrayList size() 方法

输出数组长度

size() 方法用于返回动态数组中元素的数量。

import java.util.ArrayList;

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

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 得到数组中的元素个数
        int size = sites.size();
        System.out.println("动态数组长度: " + size);
    }
}

结果：

网站列表: [Google, Runoob, Taobao]
动态数组长度: 3

Java ArrayList isEmpty() 方法

判断数组是否为空

import java.util.ArrayList;

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

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        // 检查数组中是否含有元素
        boolean result = sites.isEmpty(); // true
        System.out.println("sites 是否为空? " + result);

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 检查该数组是否为空
        result = sites.isEmpty();  // false
        System.out.println("sites 是否为空? " + result);
    }
}

结果：

sites 是否为空? true
网站列表: [Google, Runoob, Taobao]
sites 是否为空? false

Java ArrayList sort() 方法

对数组进行排序

import java.util.ArrayList;
import java.util.Comparator;

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

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        System.out.println("不排序: " + sites);

        // 元素进行升序排列
        sites.sort(Comparator.naturalOrder());
        System.out.println("排序后: " + sites);
    }
}

结果：

网站列表: [Runoob, Google, Wiki, Taobao]
不排序: [Runoob, Google, Wiki, Taobao]
排序后: [Google, Runoob, Taobao, Wiki]

降序：

import java.util.ArrayList;
import java.util.Comparator;

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

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        System.out.println("不排序: " + sites);

        // 降序
        sites.sort(Comparator.reverseOrder());
        System.out.println("降序排序: " + sites);
    }
}

结果：

网站列表: [Runoob, Google, Wiki, Taobao]
不排序: [Runoob, Google, Wiki, Taobao]
降序排序: [Wiki, Taobao, Runoob, Google]

Java ArrayList toArray() 方法

toArray() 方法将 Arraylist 对象转换为数组。

import java.util.ArrayList;
import java.util.Comparator;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 创建一个新的 String 类型的数组
        // 数组长度和 ArrayList 长度一样
        String[] arr = new String[sites.size()];

        // 将ArrayList对象转换成数组
        sites.toArray(arr);

        // 输出所有数组的元素
        System.out.print("Array: ");
        for(String item:arr) {
            System.out.print(item+", ");
        }
    }
}

结果：

网站列表: [Runoob, Google, Wiki, Taobao]
Array: Runoob, Google, Wiki, Taobao,

Java ArrayList toString() 方法

toString() 方法将 Arraylist 对象转换为字符串。

import java.util.ArrayList;
import java.util.Comparator;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 将ArrayList转换为String类型
        String list = sites.toString();
        System.out.println("String: " + list);
    }
}

结果：

网站列表: [Runoob, Google, Wiki, Taobao]
String: [Runoob, Google, Wiki, Taobao]

Java ArrayList containsAll() 方法

containsAll() 方法用于检测 arraylist 是否包含指定集合中的所有元素。

import java.util.ArrayList;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList 1: " + sites);

        // 创建另一个动态数组
        ArrayList<String> sites2 = new ArrayList<>();

        // 往动态数组中添加元素
        sites2.add("Runoob");
        sites2.add("Google");
        System.out.println("ArrayList 2: " + sites2);

        // 检查动态数组1是否包含动态数组2
        boolean result1 = sites.containsAll(sites2);
        System.out.println("ArrayList 1 包含了 ArrayList 2 的所有元素: " + result1);

        // 检查数组2是否包含数组1
        boolean result2 = sites2.containsAll(sites);
        System.out.println("ArrayList 2 包含了 ArrayList 1 的所有元素: " + result2);
    }
}

结果：

ArrayList 1: [Google, Runoob, Taobao]
ArrayList 2: [Runoob, Google]
ArrayList 1 包含了 ArrayList 2 的所有元素: true
ArrayList 2 包含了 ArrayList 1 的所有元素: false

Java HashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

添加元素

import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  // 重复的元素不会被添加
        System.out.println(sites);
    }
}

结果：

[Google, Runoob, Zhihu, Taobao]

判断元素是否存在

import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  // 重复的元素不会被添加
        System.out.println(sites.contains("Taobao"));
    }
}

结果：

true

删除元素

import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
        System.out.println(sites);
    }
}

结果:

[Google, Runoob, Zhihu]

计算长度

import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        System.out.println(sites.size());  
    }
}

结果：

遍历元素

import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

结果：

Google
Runoob
Zhihu
Taobao

Java HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射

添加元素

import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        System.out.println(Sites);
    }
}

结果：

{1=Google, 2=Runoob, 3=Taobao, 4=Zhihu}

访问元素

import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        System.out.println(Sites.get(3));
    }
}

结果：

Taobao

删除元素

import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        Sites.remove(4);
        System.out.println(Sites);
    }
}

结果：

{1=Google, 2=Runoob, 3=Taobao}

计算大小

import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        System.out.println(Sites.size());
    }
}

结果：

迭代 HashMap

遍历HashMap

import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        // 输出 key 和 value
        for (Integer i : Sites.keySet()) {
            System.out.println("key: " + i + " value: " + Sites.get(i));
        }
        // 返回所有 value 值
        for(String value: Sites.values()) {
          // 输出每一个value
          System.out.print(value + ", ");
        }
    }
}

结果：

key: 1 value: Google
key: 2 value: Runoob
key: 3 value: Taobao
key: 4 value: Zhihu
Google, Runoob, Taobao, Zhihu,

Java HashMap isEmpty() 方法

isEmpty() 方法用于检查该 HashMap 是否为空。

import java.util.HashMap;

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

        HashMap<Integer, String> sites = new HashMap<>();
        // 检查该 HashMap 是否含有元素
        boolean result = sites.isEmpty(); // true
        System.out.println("是否为空? " + result);

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        result = sites.isEmpty(); // false
        System.out.println("是否为空? " + result);
    }
}

结果：

是否为空? true
HashMap: {1=Google, 2=Runoob, 3=Taobao}
是否为空? false

Java HashMap containsKey() 方法

判断元素是否在HashMap中键存在

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        //检查 key 为 1 是否存在
        if(sites.containsKey(1)) {
            System.out.println("key 为 1 存在于 sites 中");
        }

    }
}

结果：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
key 为 1 存在于 sites 中

Java HashMap containsValue() 方法

判断元素是否在HashMap中值存在

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        //检查映射中值value是否有Java
        if(sites.containsValue("Runoob")) {
            System.out.println("Runoob 存在于 sites 中");
        }
    }
}

结果：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Runoob 存在于 sites 中

Java HashMap replace() 方法

replace() 方法替换 hashMap 中是指定的 key 对应的 value。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 替换key为2的映射
        String value = sites.replace(2, "Wiki");

        System.out.println("Replaced Value: " + value);
        System.out.println("Updated HashMap: " + sites);
    }
}

结果：

Replaced Value: Runoob
Updated HashMap: {1=Google, 2=Wiki, 3=Taobao}

Java HashMap get() 方法

get() 方法获取指定 key 对应对 value。

获取指定键对应的值

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 得到 value
        String value = sites.get(1);
        System.out.println("key 1 对应的 value: " + value);
    }
}

结果：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
key 1 对应的 value: Google

Java HashMap getOrDefault() 方法

获取指定键对于的值，如果没有找到对应的键则默认添加一个值

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // key 的映射存在于 HashMap 中
        // Not Found - 如果 HashMap 中没有该 key，则返回默认值
        String value1 = sites.getOrDefault(1, "Not Found");
        System.out.println("Value for key 1:  " + value1);

        // key 的映射不存在于 HashMap 中
        // Not Found - 如果 HashMap 中没有该 key，则返回默认值
        String value2 = sites.getOrDefault(4, "Not Found");
        System.out.println("Value for key 4: " + value2);
    }
}

结果：

Value for key 1:  Google
Value for key 4: Not Found

以上来自菜鸟教程

搜索

复制

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/tech/java/281462.html

Java 常用类和方法

Java Math 类

Java equals() 方法

Java valueOf() 方法

语法

参数

返回值

Java toString() 方法

Java parseInt() 方法

语法

参数

返回值

Java abs() 方法

Java round() 方法

Java min() 方法

Java max() 方法

Java pow() 方法

Java sqrt() 方法

Java random() 方法

Java Character 类

Java isLetter() 方法

Java isDigit() 方法

Java isUpperCase() 方法

Java isLowerCase() 方法

Java toUpperCase() 方法

Java toLowerCase() 方法

Java String 类

Java charAt() 方法

Java String equals() 方法

Java startsWith() 方法

Java endsWith() 方法

Java String indexOf() 方法

Java String length() 方法

Java replace() 方法

Java split() 方法

Java substring() 方法

语法

参数

Java toCharArray() 方法

Java valueOf() 方法

Java StringBuffer 和 StringBuilder 类

Java StringBuffer append()方法

Java StringBuffer reverse()方法

Java StringBuffer delete()方法

Java StringBuffer insert()方法

Java StringBuffer replace()方法

Java ArrayList

Java ArrayList add() 方法

Java ArrayList clone() 方法

Java ArrayList contains() 方法

Java ArrayList get() 方法

Java ArrayList indexOf() 方法

Java ArrayList remove() 方法

Java ArrayList size() 方法

Java ArrayList isEmpty() 方法

Java ArrayList sort() 方法

Java ArrayList toArray() 方法

Java ArrayList toString() 方法

Java ArrayList containsAll() 方法

Java HashSet

添加元素

判断元素是否存在

删除元素

计算长度

遍历元素

Java HashMap

添加元素

访问元素

删除元素

计算大小

迭代 HashMap

Java HashMap isEmpty() 方法

Java HashMap containsKey() 方法

Java HashMap containsValue() 方法

Java HashMap replace() 方法

Java HashMap get() 方法

Java HashMap getOrDefault() 方法

相关推荐

发表回复