java常用类及接口

最新推荐文章于 2024-10-02 20:39:31 发布

原创最新推荐文章于 2024-10-02 20:39:31 发布 · 1.5k 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#java

Java 专栏收录该内容

9 篇文章

订阅专栏

1.1 java API类库

Java运行环境 (Java Runtime Environment，JRE)为一般的应用开发提供了大量类库支持，其提供的基础类库被称为JFC。这些系统定义好的类根据实现的功能不同，可以划分成不同的集合，每个集合是一个包，合称类库。

java类库主要有以下几种：

java.lang

Java语言的核心类库，定义了Java中的Object、String、Boolean、Byte、Short、Math、System、Runtime等大多数基本类。不需要用import引入。

java.io

标准输入和输出类库，通过数据流、序列化和文件系统提供系统输入和输出。

java.util

包括许多具有特定功能的类，有日期、向量、哈希表、堆栈等，其中Date类支持与时间有关的操作。

javax.swing、java.awt

提供了创建图形用户界面元素的类。

java.awt.event

提供处理由AWT组件所激发的各类事件的接口和类。

java.applet

用来实现运行于浏览器中的Java Applet的工具类库。

java.net

与网络编程相关的类库。

java.sql

用来实现JDBC（Java Data Connection）的类库，利用它可以使Java程序具有访问不同类的数据库的功能。

java.text

通过与特定语言无关的方式格式化文本消息、日期和数值。

1.2 Java.lang包

Java.lang包是由Java程序默认import的，它提供了大多数常用的基本类：八种包装类、字符串类（String、StringBuffer）、数学函数类（Math）、系统类（System）、随机数类（Random）、运行时类（Runtime）等。

1.2.1 Object

Object类是类层次的根。
所有类都直接或间接地继承了Object类，所以一个Object类型的变量可以引用任何对象，不论是类实例还是数组。Object类定义了11个可供所有对象继承的方法。这些方法分为两类：通用工具方法和支持线程的方法。

其中有两个比较重要的方法：

equals方法——用于检测一个对象是否等于另外一个对象。
在Object类中，这个方法判断两个对象是否具有相同的引用。如果两个对象具有相同的引用，它们一定是相等的。从这点上看，将其作为默认操作是合理的。然而，对于多数类来说，这种判断并没有什么意义。（因与“==”区分开来，“==”是比较和判断两个对象的值是否相等）
在自定义的类中，应该覆盖这个方法。

hashCode方法——返回对象的散列码。
由于hashCode方法定义在Object类中，因此每个对象都有一个默认的散列码，其值为对象的存储地址。
如果重新定义了equals方法，就必须重新定义hashCode方法，以便用户可以将对象插入到散列表中。
equals与hashCode的定义必须一致：如果x.equals(y)返回true，那么x.hashCode()就必须与y.hashCode()具有相同的值。

除了这两个方法外，还有一个比较重要的方法：toString方法——Object类中toString()只提供了该对象的类名、一个@字符和实例散列码的十六进制表示，通常这些信息对于用户是远远不够的。
在自定义的类中应该覆盖这个方法，在其中提供一些更加友好的信息。

以及一些其他方法：finalize方法（当系统中没有引用变量引用到该对象时，垃圾回收器调用此方法来清理该对象的资源）、getClass方法（返回包含对象信息的类对象。Java提供了类运行时的描述，它的内容被封装在Class类中）、clone方法（创建一个对象的副本。Java运行时系统将为新实例分配存储空间，并将当前的对象复制到这块存储区域中。默认的clone方法只是一种“浅克隆”，它只克隆该对象所有的域值，不会对引用类型的域值所引用的对象进行克隆）。

1.2.2 基本数据类型的封装

Java中定义了多种基本数据类型，但为了与面向对象程序设计思想相符合，Java基本类库中同时提供了对这些基本类型的封装类。

这些类一般有如下特点：

类中定义了对应基本数据类型的一些常数；
提供基本数据类型和字符串的相互转换方法；
对象中封装的值是不可改变的，改变对象值的惟一方法是创建一个新的对象；
作为典型的值类实现，对equals()、hashCode()和toString()方法都做了改写。

1.2.3 System

java.lang.System类是个很特殊的类，该类不能被实例化，是个非常典型的静态方法类，主要提供与系统相关的静态方法和一些静态对象，如标准输入输出。如：System.out.println(“”);

1.2.4 Math

java.lang.Math类用来完成一些常用的数学计算，提供了一些实现标准数学函数计算的静态方法，使用时无需创建实例。如：Math.PI;

与字符串相关类

String与StringBuffer

String是Java中比较特殊的数据类型。Java语言将字符串作为对象来处理，有对应的类定义，每一个字符串常量是字符串类String的一个实例。String类中提供了很多非常方便的字符串操作和查询方法。
StringBuffer类封装了一个字符数组，同时提供了对这个字符数组的相关操作。与String相比，任何修改性的操作都是在同一个字符数组上进行，而不像String那样为了线程访问安全创建大量副本对象。

例：字符串的解析和分割

public String[ ] split(String regex)
    根据给定的正则表达式的匹配来拆分此字符串。
   （查看java.util.regex.Pattern的文档）

String[] result = "this is an apple".split("\\s");
    // \s --空白字符 
    for (int x=0; x<result.length; x++)
        System.out.println(result[x]);

1.3 Java.util包

日期和时间

Date类提供了操作时间的基本功能。
Date() //使用当前日期和时间初始化对象
Date(long milliseconds) //参数等于从1970年1月1日午夜开始计算已经过去的时间数（毫秒）。
Date中的很多方法已经过时。
Date类没有提供允许获得日期和时间的各个组成成分的方法，只能获得毫秒计数的日期和时间，或者从toString()方法所返回的字符串表示中获得日期和时间。如要获得日期和时间的详细信息，则需使用Calendar类。

import java.util.*;

public class Test {
     public static void main(String[] args) {
         Date date=new Date();
         System.out.println(date);
         long msec=date.getTime();
         System.out.println("Milliseconds=" +msec);
     }
}

Calendar类是一个抽象类，提供了一组允许把毫秒为单位的时间转换为一些有用时间成分，如年、月、日、时、分和秒的方法。
Calendar 提供了一个类方法 getInstance()，返回一个GregorianCalendar对象（格林高利历，公历），这个对象被初始化成默认地域和时区下的当前日期和时间。
Calendar还定义了很多int型的常量，这些常量一般在获取或设置Calendar类的成员时使用

import java.util.*;

class Test{
    public static void  main(String[] args){
        Calendar now=Calendar.getInstance();
        System.out.println(now.get(Calendar.YEAR));
    }
}

Random

Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子（seed），在种子数的基础上进行一定的变换，从而产生需要的随机数。

Java的集合框架

集合是一系列对象的聚集，是代表一组对象的一个对象，集合中的这一组对象称为集合的元素。集合中的每一个元素都具有一定的数据类型，任何数据类型的对象都可以存放在集合中。

集合是Java程序设计中非常重要的数据结构形式，Java基本类库中提供了非常优秀的集合相关类定义实现，一般称为集合API。
集合API中的接口和类主要分布在Java.util包下，最基本的接口是Collection，定义了聚集形式数据的基本操作方法。

Java的集合框架能使Java程序处理对象集的方式变得标准化。
整个集合框架被设计成一系列标准接口，并且实用工具包中提供了这些接口的几个标准实现，如LinkedList、HashSet和TreeSet。

集合框架所产生的另一个东西是Iterator（迭代器）接口。Iterator接口提供了访问集合元素的一种标准访问方式：逐个访问方式，或者说，Iterator接口提供了列举集合内容的一种标准访问方式。由于每个集合均实现Iterator接口，所以任何集合类成员均可通过Iterator类的方法来访问。
除了集合之外，集合框架还定义了几个映射（Map）接口与类。映射接口与类用来存储键-值对。从严格的意义上来说，映射不是集合，但它们被完全集成到了集合中，可以像处理集合一样来处理映射的内容。

Collection接口

Collection接口是构造集合框架的基础，并声明了各种集合所共有的核心方法。
由于所有集合都必须实现Collection接口，所以熟悉该接口所定义的方法对弄清楚集合框架是至关重要的。

List接口（基本表结构）

List接口扩展了Collection接口，并把集合的行为声明成存储一个元素序列。使用从0开始的索引，可以把一个元素插入到列表中或访问列表中的某个元素。同一个列表可以包含相同的元素。除了Collection接口所定义的方法之外，List接口还定义了属于它自己的一些方法。

ArrayList类

支持按需增长的动态数组。

构造方法：
    ArrayList( )   
   //创建空数组列表
    ArrayList(Collection c)   
   //以集合c中的元素作为初始元素创建数组列表
    ArrayList(int capacity)   
   //创建一个具有指定初始容量的数组列表

（支持使用泛型编程）

import java.util.*;
class Test{
    public static void  main(String[] args){
        ArrayList alist=new ArrayList();
        alist.add("a");
        alist.add("b");
        alist.add("c");
        alist.add("d");
        alist.add(1,"ok");
        System.out.println(alist);
        alist.remove("c");
        alist.remove(3);
        System.out.println(alist);
    }
}

LinkList类

LinkedList采用链表结构实现List接口。
除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。
LinkedList还实现了Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

构造方法：
LinkedList() 
    构造一个空列表。
LinkedList(Collection<? extends E> c) 
    构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。

数制转换

import java.util.*;

public class Test {
    public static void conversion(int n, int r) {
        LinkedList<Integer> s = new LinkedList<Integer>(); // 定义栈s

        while (n != 0) {    // 只要n不为0，n除基数
            s.push(n % r);  // 余数入栈
            n = n / r;      // n取整数部分
        }
        while (!s.isEmpty()) { // 栈不为空，出栈
            System.out.print(s.pop());
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Test.conversion(1348, 8);
    }
}

本程序体现了：装箱：基本类型自动转为对应包装类型、
拆箱：包装类型转基本类型

Set接口（集合）

Set接口扩展Collection接口并定义这样一种集合：这种集合不允许含有相同的元素。Set接口没有定义它自己的方法。

TreeSet

用树结构来存储数据，集合中的对象按“升序” *存储，访问和遍历集合的速度很快，是存储大量数据并快速查找的上佳选择。

TreeSet()  //按照元素的自然顺序排序。插入该 set 的所有元素都必须实现 Comparable 接口
TreeSet(Collection c)  //构造一个用c集合的元素为初始元素的树集合
TreeSet(Comparator comp)　//构造一个按comp比较器排序的空树集合
TreeSet(SortedSet sset)　//构造一个用sset集合作为初始元素的树集合

*根据使用的构造方法不同，可能会按照元素的自然顺序进行排序（参见 Comparable），或按照在创建 set 时所提供的比较器进行排序。

import java.util.*;

class StrComparator implements Comparator {
    public int compare(Object o1, Object o2) {
        String a = (String) o1;
        String b = (String) o2;
        int c = a.compareTo(b);
        if (c > 0)
            return -1;
        else if (c < 0)
            return 1;
        else
            return 0;
    }
}

public class Test {
    public static void main(String[] args) {
        TreeSet aset = new TreeSet();
        aset.add("d");
        aset.add("b");
        aset.add("a");
        aset.add("c");
        for (Object ob : aset)
            System.out.print((String) ob + "\t");
        System.out.println();

        TreeSet bset = new TreeSet(new StrComparator());
        bset.addAll(aset);
        bset.add("e");
        for (Object ob : bset)
            System.out.print((String) ob + "\t");
    }
}

输出：
a   b   c   d   
e   d   c   b   a

Comparable比较器接口

此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
实现此接口的对象列表（和数组）可以通过 Collections.sort()（和 Arrays.sort()）进行自动排序。实现此接口的对象可以用作有序映射表中的键或有序集合中的元素，无需指定比较器。

import java.util.*;

class Student implements Comparable {
    int id;
    String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int compareTo(Object s) {
        Student ss = (Student) s;
        return id - ss.id;
    }
}

public class Test {
    public static void main(String[] args) {
        TreeSet aset = new TreeSet();
        aset.add(new Student(3, "c"));
        aset.add(new Student(2, "b"));
        aset.add(new Student(1, "a"));
        aset.add(new Student(4, "d"));
        for (Object ob : aset) {
            Student s = (Student) ob;
            System.out.println(s.id + "\t" + s.name);
        }
    }
}

输出：
1   a
2   b
3   c
4   d

迭代器

遍历集合中的元素是一个常见的操作，比如显示集合中的每个元素。要想遍历集合中的元素，可使用迭代器。
迭代器是指实现了Iterator或ListIterator接口的一个对象。
迭代器允许通过循环集合来获取或删除集合元素。ListIterator通过扩展Iterator来允许双向遍历和修改集合元素。

Iterator接口

ListIterator接口

要想用迭代器访问集合，必须先获得迭代器。每个集合类均提供了一个返回迭代器的iterator()方法，而且返回的迭代器均指向当前集合的开头。
通常情况下，使用迭代器遍历集合应该遵循以下步骤：
①调用集合的iterator()方法获取一个指向集合开头的迭代器。
②设置一个循环来调用hasNext()方法，其中只要hasNext()方法返回true，循环就继续进行。
③在循环体中，调用next()方法来获得每个元素。
对于实现了List接口的集合，还可以通过调用ListIterator()来获得迭代器。

import java.util.*;

class Test {
  public static void main(String[] args) {
    ArrayList<String> alist = new ArrayList<>();
    alist.add("a");
    alist.add("b");
    alist.add("c");
    alist.add("d");
    Iterator<String> itr01 = alist.iterator();
    while (itr01.hasNext()) {
      String element = itr01.next();
      System.out.print(element + " ");
    }
    ListIterator<String> itr02 = alist.listIterator();
        while (itr02.hasNext()) {
          String element = itr02.next();
          itr02.set(element + "-");
        }

        System.out.println();
        while (itr02.hasPrevious()) {
          String element = itr02.previous();
          System.out.print(element + " ");
        }
      }
    }

输出：

a b c d 
d- c- b- a-

Map接口

TreeMap类

TreeMap类使用树形结构实现Map接口，它提供了按序相邻存储关键字－值对的有效方式。

构造函数：
TreeMap()
创建一个按关键字自然顺序进行排序的空的映射。
TreeMap(Comparator comp)
创建一个按comp比较器进行排序的空的映射。
TreeMap(Map m)
用m映射的元素作为初始元素创建一个树形映射。
TreeMap(SortedMap sm)
用sm有序映射的映射作为初始元素按照sm有序映射的相同顺序创建一个树形映射。


import java.util.*;

public class Test {
  public static void main(String[] args) {
    TreeMap<String,String> tm = new TreeMap<>();
    tm.put("red", "红色");
    tm.put("green", "绿色");
    tm.put("blue", "蓝色");

    System.out.println(tm.get("red"));    
  }
}

输出：
红色


public class Test {
  public static void main(String[] args) {
    TreeSet aset = new TreeSet();
    aset.add(new Student(3, "c"));
    aset.add(new Student(2, "b"));
    aset.add(new Student(1, "a"));
    aset.add(new Student(4, "d"));
    for (Object ob : aset) {
      Student s = (Student) ob;
      System.out.println(s.id + "\t" + s.name);
    }
  }
}

public class Test {
  public static void main(String[] args) {
    TreeSet<Student> aset = new TreeSet<Student>();
    aset.add(new Student(3, "c"));
    aset.add(new Student(2, "b"));
    aset.add(new Student(1, "a"));
    aset.add(new Student(4, "d"));
    for (Student ob : aset) {
      Student s = ob;
      System.out.println(s.id + "\t" + s.name);
    }
  }
}