Object类

Object 类是所有类的父类，也就是说 Java 的所有类都继承了Object，子类可以使用Object的所有方法。
Object类位于java.lang包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承Object，成为Object的子类。
Object 类可以显式继承，也可以隐式继承，以下两种方式时一样的：
- 显式继承
```
public class test extends Object{}
```
- 隐式继承
```
public class test{}
```

clone方法

package Demo;

// Object 本身没有实现 Cloneable 接口，所以不重写 clone 方法并且进行调用的话会发生 CloneNotSupportedException 异常
// clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存，相对应的深拷贝则会连引用的对象也重新创建
public class Application implements Cloneable {

    int age;

    public static void main(String[] args) {
        Application obj1 = new Application();
        // 实例化后赋具体值
        obj1.age = 10;
        try {
            Application obj2 = (Application) obj1.clone();
            System.out.println(obj1.age);
            System.out.println(obj2.age);
        } catch (Exception e) {
            System.out.println("wrong");
        }
    }
}

equals方法:equals()方法比较两个对象，是判断两个对象引用指向的是同一个对象，即比较 2 个对象的内存地址是否相等。如果子类重写了 equals()方法，就需要重写hashcode()方法

package Demo;

// 一个项目应该只存在一个main方法
public class Application implements Cloneable {

    int age;

    public static void main(String[] args) {
        Application obj1 = new Application();
        // 对象引用，内存地址相同，相等，返回 true
        Object obj3 = obj1;
        // 实例化后赋具体值
        obj1.age = 10;
        try {
            // 新创建了对象,内存地址不同
            Application obj2 = (Application) obj1.clone();
            System.out.println(obj1.equals(obj2));
            System.out.println(obj1.equals(obj3));
        } catch (Exception e) {
            System.out.println("wrong");
        }
    }
}

hashCode()

package Demo;

import java.util.ArrayList;

// 一个项目应该只存在一个main方法
public class Application implements Cloneable {
    public static void main(String[] args) {
        String obj1 = new String();
        ArrayList<Integer> obj2 = new ArrayList<>();
        String obj3 = obj1;

        System.out.println(obj1.hashCode());
        System.out.println(obj2.hashCode());
        System.out.println(obj3.hashCode());
    }
}

arraylist类

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素
ArrayList 中的元素实际上是对象, ArrayList<E> 只能为引用数据类型，这时我们就需要使用到基本类型的包装类
Collections 类可以用于排序，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序

package Demo;

import java.util.ArrayList;
import java.util.Collections;

// 一个项目应该只存在一个main方法
public class Application implements Cloneable {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("google");
        sites.add("facebook");
        System.out.println(sites.get(1));  // 获取值
        sites.set(1, "baidu");  // 修改值
        sites.add("ali");
        sites.remove(2);  // 移除元素
        System.out.println(sites);
        System.out.println(sites.size());  // 计算数组大小
        Collections.sort(sites);  // 排序
        for (int i = 0; i < sites.size(); i++) {  // 遍历
            System.out.print(" " + sites.get(i));
        }
    }
}

linklist类

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。
- 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。
- 一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接
Java LinkedList（链表）类似于 ArrayList，是一种常用的数据容器。与 ArrayList相比，LinkedList 的增加和删除对操作效率更高，而查找和修改的操作效率较低。
以下情况使用 ArrayList :
- 频繁访问列表中的某一个元素。
- 只需要在列表末尾进行添加和删除元素操作。
以下情况使用 LinkedList :
- 你需要通过循环迭代来访问列表中的某些元素。
- 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

import java.util.LinkedList;

public class Hello {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("google");
        sites.add("baidu");
        sites.addFirst("Wiki");  // 在头部添加元素,删除removeFirst,获取getFirst
        sites.addLast("facebook");  //在尾部添加元素,删除removeLast,获取getLast
        System.out.println(sites);
        for (int i = 0; i < sites.size(); i++) {
            System.out.println(sites.get(i));
        }
    }
}

HASHSET类

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。
HashSet 允许有 null 值。
HashSet 是无序的，即不会记录插入的顺序
HashSet 不是线程安全的，如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。您必须在多线程访问时显式同步对 HashSet 的并发访问。

import java.util.HashSet;
import java.util.LinkedList;

public class Hello {
    public static void main(String[] args) {
        HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.clear();  // 清除所有元素
        sites.add("Zhihu");
        sites.add("Runoob");  // 重复的元素不会被添加
        sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
        System.out.println(sites);
        System.out.println(sites.contains("Taobao"));  // 判断元素是否存在
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

hashmap类

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。
HashMap 是无序的，即不会记录插入的顺序。
HashMap 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类

import java.util.HashMap;

public class Hello {
    public static void main(String[] args) {
        HashMap<Integer, String> sites = new HashMap<Integer, String>();
        // put添加键值对
        sites.put(1, "google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        sites.put(4, "Zhihu");
        System.out.println(sites.get(3));  // 获取特定值
        sites.remove(4);  // 移除值
        // sites.clear();  清除所有值
        System.out.println(sites.size());  // 获取数组大小
        for (Integer i : sites.keySet()) {  // 迭代输出key和value
            System.out.println("key: " + i + " value: " + sites.get(i));
        }
    }
}

Iterator类

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList和 HashSet等集合

import java.util.ArrayList;
import java.util.Iterator;

public class Hello {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(12);
        numbers.add(8);
        numbers.add(2);
        numbers.add(23);

        // 获取迭代器
        Iterator<Integer> it = numbers.iterator();
        while (it.hasNext()) {
            Integer i = it.next();
            if (i < 10) {
                it.remove();
            }
        }
        System.out.println(numbers);
    }
}

StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

package Demo;

import java.util.ArrayList;
import java.util.Collections;

// 一个项目应该只存在一个main方法
public class Application implements Cloneable {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer(20);
        sb.append("Runoob..");
        System.out.println(sb);
        sb.append("!");
        System.out.println(sb);
        sb.insert(4, "java");
        System.out.println(sb);
        sb.delete(5, 8);
        System.out.println(sb);
    }
}

出　　处：https://www.cnblogs.com/hanxueyan/p/14860924.html

栏目列表

首页 > 编程开发 > Java教程 >

第八课-Java常用类

Object类

arraylist类

linklist类

HASHSET类

hashmap类

Iterator类

StringBuffer 和 StringBuilder 类