工具类及常用算法

Java基础类库

Java基础类库

java.lang.Object类

Object类是Java程序中所有类的直接或间接父类

equals()

  • 用来比较两个对象是否相同,如果相同,则返回true;否则返回false;

  • 它比较的是两个对象状态和功能上的相同,而不是引用上的相同;

  • Object.equals默认实现

    1
    2
    3
    public boolean equals(Object obj){
    return (this==obj);
    }
  • Integer.equals实现

    1
    2
    3
    4
    5
    6
    public boolean equals(Object obj){
    if(obj instanceof Integer){
    return value==((Integer)obj).intValue();
    }
    return false;
    }
  • String.equals实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    //ch07.eq.TestEqualsString
    //ch07.eq.TestEqualsObject
    public boolean equals(Object anObject){
    if(this==anObject){
    return true;
    }
    if(anObject instanceof String){
    String anotherString=(String)anObject;
    int n=value.length;
    if(n==anotherString.value.length){
    char v1[]=value;
    char v2=another.value;
    int i=0;
    while(n--!=0){
    if(v1[i]!=v2[i])
    return false;
    i++;
    }
    return true;
    }
    }
    return false;
    }
  • 在强调一次,equals()比较的是两个对象状态和功能上的相同,而不是引用上的相同

    1
    2
    3
    4
    5
    6
    Integer one=new Integer(1);
    Integer anotherOne=new Integer(1);
    if(one.equals(anotherOne)){
    System.out.println("Objects are equal");
    }
    //例中,equals方法返回true,因为对象One和anotherOne包含相同的数值1

getClass()

getClass()方法是final方法,它不能被重载;

它返回一个对象在运行时所对应的类的表示,从而可以得到相应的信息。

下面的方法得到并显示对象的类名:

1
2
3
void PrintClassName(Object obj){
System.out.println("The object's class is"+obj.getClass().getName());
}

toString()

toString()方法用来返回对象的字符串表示,可以用来显示一个对象;

通过重载toString()方法可以适当地显示对象的信息以进行调试。

finalize()

用于在垃圾收集前清楚对象。

基本数据类型的包装类

基本数据类型的包装类

double转成String的几种方法

d2S

String转成double的几种方法

S2d

Math类

Math类

Math类

System类

1
//ch07.SystemDemo

System类

字符串

程序中需要用到的字符串可以分为两大类,一类是创建之后不会再做修改和变动的字符串常量;另一类是创建之后允许再做更改和变化的字符串。前者是String类,后者是StringBuffer/StringBuilder类。

  • Character:这个类的实例可以容纳单一的字符数值。该类还定义了一些简洁的方法来操作或者检查单一字符数据;
  • String:这个类用于处理由多个字符组成的不可变数据;
  • StringBuffer:这个类用于存储和操作由多个字符组成的可变数据;
  • StringBuilder:基本同StringBuffer。

集合类

Java集合类框图

Java集合类框图

  • Set:无序,唯一;
  • List:有序,不唯一;
  • Map:key→value。

Set(集)

定义

  • Set是最简单的集合,集合中的对象不按照特定的方式排序,并且没有重复地对象;
  • Set接口主要有两个实现类:
    • HashSet;
    • TreeSet。

一般用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//ch07.set.SetDemo
package ch07.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Set set = new HashSet();
String str = "我是天津大学一名学生";
char[] chars = str.toCharArray();
for (int i = 0; i<chars.length; i++) {
set.add(chars[i]);
}
System.out.println("不同字符数量: " + set.size());
printSet(set);
}
public static void printSet(Set set) {
// 遍历一个set的方法
Iterator it = set.iterator();
while (it.hasNext()) {
System.out.print(it.next());
}
}
}
//ch07.set.SetDemo2
  • Set集合中存放的是对象,并且没有重复对象;

  • Java中实现Set接口的类很多,例如

    1
    Set set=new HashSet();
  • 这样就创建了一个集合对象,我们把它当作抽象接口看待;

  • 使用接口的好处在于,实现类将来可以被替换,而程序不用做很多改动。

HashSet类

  • HashSet类按照哈希算法来存取集合中的对象,具有很好的存取和查找性能;
  • 当向集合中加入一个对象时,HashSet会调用对象的hashCode()方法来获得哈希码,然后根据哈希码进一步计算出对象在集合中的位置。

散列技术的原理

  • 把对象的哈希码直接用一个固定的公式计算,得出存储位置的方法;
  • 优点是:可以快速命中搜索的目标。

散列技术的原理

HashSet正常工作的前提

两个你认为相同的对象其hashCode()必须相同且两个对象用equals()方法比较的结果为true

1
//ch07.set.SetHashCodeEqDemo

TreeSet类

  • TreeSet采用树结构来存储数据,数据打印出来是有序的;
  • 当向集合中加入一个对象时,会把它插入到有序的对象集合中;
  • TreeSet支持两种排序方式:
    • 自然排序;
    • 自定义排序。
  • 默认情况下采用自然排序。

自然排序

要求被排序的对象实现了Comparable接口的compareTo(Object o)方法

1
2
3
4
x.compareTo(y)
x==y return 0;
x>y return +;
x<y return -;

在JDK类库中已经实现Comparable接口的一些类

Comparable

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//TreeSet的自然排序
//ch07.set.TreeSetDemo
package ch07.set;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import ch07.Student;
import ch07.bak.Dog;
public class TreeSetDemo {
public TreeSetDemo() {
// TODO Auto-generated constructor stub
}
public static void main (String[] args) {
// TODO Auto-generated method stub
Set set = new TreeSet();
set.add(0);
set.add(5);
set.add(2);
set.add(01);
Object[] ds = set.toArray( );
for (int i = 0; i < ds.length; i++) {
System.out.println(ds[i]);
}
}
}
//ch07.set.TreeSetDemo2

自定义排序

遍历Set

Method1

1
2
3
4
5
6
7
Set set=new TreeSet();
set.add(new Integer(0));......
int sum=0;
Integer[] list=(Integer[])set.toArray(new Integer[0]);
for(int i=0;i<list.length;i++){
sum=sum+list[i];
}

Method2

1
2
3
4
5
6
7
Set set=new TreeSet();
set.add(new Integer(0));......
int sum=0;
Object[] list=set.toArray();
for(int i=0;i<list.length;i++){
sum=sum+(Integer)list[i];
}

Method3

1
2
3
4
5
6
7
Set set=new TreeSet();
set.add(new Integer(0));......
int sum=0;
Iterator it=set.iterator();
while(it.hasNext()){
sum=sum+(Integer)it.next();
}

Set用途

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//ch07.set.TreeSetUsage
package ch07.set;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TreeSetUsage {
public TreeSetUsage() {
// TODO Auto-generated constructor stub
}
public static void main(String[] args) {
Set set = new TreeSet();
String content = "China will strengthen international cooperation on novel coronavirus epidemic control and continue to provide assistance within its ability to countries affected by the epidemic, Xi Jinping, general secretary of the Communist Party of China Central Committee, said on Wednesday.";
String[] words = content.split(" ");
for (int i = 0; i < words.length; i++) {
String word = words[i];
set.add(words[i]);
}
Iterator it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
  • 保存/统计不重复的对象
    • 判断一个文本有多少不同字符;
    • 判断一个文本有多少不同字符单词、汉字;
    • 判断一个对象是否已经存在了;
  • 使用TreeSet还可以快速排序

List(列表)

定义

  • List的主要特征是按照元素以先行方式存储,允许集合中存放重复对象;

  • List接口的主要实现包括:

    • ArrayList;
    • LinkedList。
  • ArrayList:代表长度可以变化的数组。允许对元素进行快速的随机访问,但是向ArrayList中插入与删除元素速度较慢;

  • LinkedList:双向链表。向LinkedList中插入和删除元素的速度较快,随机访问的速度较慢

    1
    2
    3
    4
    5
    6
    7
    //它单独具有以下方法
    addFirst()
    addLast()
    getFirst()
    getLast()
    removeFirst()
    removeLast()

访问List中的元素

List中的对象按照索引位置排序,程序可以按照对象在集合中的索引位置来检索对象。

访问List中的元素

List特性

  • 保持原来加入时候的顺序;
  • List中可以有重复元素;
  • List本身不带有排序的功能;
  • Collections类是对Java集合类库中的辅助类,它提供操纵集合的各种静态方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//对List中对象进行自然排序
Collections.sort(List list);
//ch07.list.SortList
package ch07.list;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SortList {
public SortList() {
// TODO Auto-generated constructor stub
}
public static void main(String[] args) {
// TODO Auto-generated method stub
List list=new ArrayList ();
list.add(12);
list.add(34);
list.add(11);
Collections.sort(list);
for(int i=0;i<list.size();i++) {
System.out.println(list.get(i));
}
}
}

通途

  • 按顺序存放元素,比数组更方便。

Vector

  • Vector类可以实现动态的对象数组。几乎与ArrayList相同;
  • 由于Vector在各个方面都没有突出的性能,所以现在已经不提倡使用。

Map(映射)

定义

  • Map:集合中的每一个元素包含一对键对象和值对象,集合中没有重复的键对象,值对象可以重复;
  • 向Map集合中加入元素时,必须提供一对键对象和值对象;
  • Map的两个主要实现类:
    • HashMap;
    • TreeMap。
  • Map最基本的用法,就是提供类似字典的能力;
  • 在Map中检索元素时,只要给出键对象,就会返回值对象。

Java集合类框图

Map的遍历

Method1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//通过Set.keySet()返回键的集合来遍历
//ch07.map.MapIterator
package ch07.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class MapIterator {
public static void main(String[] args) {
String str = "China will strengthen international cooperation on novel coronavirus epidemic control and continue to provide assistance within its ability to countries affected by the epidemic, Xi Jinping, general secretary of the Communist Party of China Central Committee, said on Wednesday.";
String freq = getFrequentWord(str);
System.out.println(freq);
}
public static String getFrequentWord(String content) {
Map map = new HashMap();
String[] words=content.split(" ");
for(int i=0;i<words.length;i++) {
String word = words[i];
int count = 0;
if (map.containsKey(word)) {
count = (Integer) map.get(word);
}
map.put(word, count + 1);
}
Iterator it = map.keySet().iterator();
int maxCount = 0;
String maxKey = "";
while (it.hasNext()) {
String key = (String) it.next();
if ((Integer) map.get(key) > maxCount) {
maxKey = key;
maxCount = (Integer) map.get(key);
}
}
System.out.println(maxKey+"="+maxCount);
return maxKey;
}
}

Method2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//通过Set.entrySet()返回"键值对"的集合来遍历
//Map.Entry的对象代表一个"词条",就是一个键值对
//可以从中取值getValue()或键getKey()
//ch07.map.MapIterator2
package ch07.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
public class MapIterator2 {
public static void main(String[] args) {
String str = "China will strengthen international cooperation on novel coronavirus epidemic control and continue to provide assistance within its ability to countries affected by the epidemic, Xi Jinping, general secretary of the Communist Party of China Central Committee, said on Wednesday.";
String freq = getFrequentWord(str);
System.out.println(freq);
}
public static String getFrequentWord(String content) {
Map map = new HashMap();
String[] words=content.split(" ");
for(int i=0;i<words.length;i++) {
String word = words[i];
int count = 0;
if (map.containsKey(word)) {
count = (Integer) map.get(word);
}
map.put(word, count + 1);
}
Iterator it = map.entrySet().iterator();
int maxCount = 0;
String maxKey = "";
while (it.hasNext()) {
Entry entry=(Entry)it.next();
String key = (String) entry.getKey() ;
if ((Integer) entry.getValue() > maxCount) {
maxKey = key;
maxCount = (Integer) map.get(key);
}
}
System.out.println(maxKey+"="+maxCount);
return maxKey;
}
}

Map两个最重要实现

  • HashMap按照哈希算法来存取键值对象;
  • TreeMap按照排序规则对keySet进行排序。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//Map的遍历不保证顺序
//但是TreeMap遍历使用Key排序
//ch07.map.HashMapTreeMap
package ch07.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* 本例子演示了TreeMap和HashMap区别
*/
public class HashMapTreeMap {
Comparable c;
public static void main(String[] args) {
testMap(new HashMap());
System.out.println("=====================");
testMap(new TreeMap());
}
public static void testMap(Map map) {
map.put("zhang", 10);
map.put("li", 20);
map.put("wan", 30);
map.put("an", 40);
Iterator it = map.keySet().iterator();
while (it.hasNext()) {
Object key = it.next();
Object value = map.get(key);
System.out.println(key + " " + value);
}
}
}
//Output
/*
wan 30
zhang 10
li 20
an 40
=====================
an 40
li 20
wan 30
zhang 10
*/

Points

  • JDK API文档可以从far fa-hand-point-right下载,安装后,打开index.html即可;

  • 点击获取Java文档

  • Java最权威的教材

  • Iterator

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //不考虑泛型的Iterator定义
    public interface Iterator{
    boolean hasNext();
    Object next();
    void remove();
    }
    public interface Collection extends Iterable;
    public interface Iterable{
    Iterator iterator();
    }
  • Collection和Iterator接口

    • 在Collection接口中声明了适用于Java集合(只包括Set和List)的通用方法。因此Set和List对象可以调用以上方法,Map对象不可以;
    • Iterator接口隐藏了底层集合的数据结构,向客户程序提供了遍历各种数据集合的统一接口;
    • 如果集合中的元素没有排序,Iterator遍历集合中元素的顺序也是无序的。
  • 使用Iterator遍历Set/List

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    //ch07.it.IteratorDemo
    package ch07.it;
    /**
    * 本例子演示了Iterator的用法
    */
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Set;
    public class IteratorDemo {
    public IteratorDemo() {
    // TODO Auto-generated constructor stub
    }
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    List list=new ArrayList();
    addObject(list);
    itColleciton(list);
    Set set=new HashSet();
    addObject(set);
    //留意 itColleciton(set) 和 itColleciton(list) 区别
    itColleciton(set);
    }
    public static void addObject(Collection collection) {
    collection.add("天津");
    collection.add("大学");
    }
    public static void itColleciton(Collection collection) {
    Iterator it=collection.iterator();
    while(it.hasNext()) {
    System.out.println(it.next());
    }
    }
    }

文章源码

文章源码 备用仓库