Java Math 类

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

 

 

 

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);
        }
}

结果：

9
5.0
80.0
1092

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)); 
    }
}

结果：

101
101
100
90

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);
    }
}

结果：

n

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  
    }
}

结果：

-1
6
7
7
6
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());  
    }
}

结果：

4

遍历元素

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());
    }
}

结果：

4

迭代 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

以上来自菜鸟教程

 

 

 

 

搜索

复制