Java PTA(10)——Java常用类

equals(Object obj)方法的格式是：

        public boolean equals(Object obj)

功能：当参数obj引用的对象与当前对象为同一个对象时，返回true，否则返回false。 obj1.equals(obj2)的效果相当于obj1==obj2。

例如，平面点类Point是空间点类Point3D的超类。

        Point point1 = new Point();

        Point point2 = new Point3D();

        Point point3 = point1;

        System.out.println(point1 == point2);     // 打印false         System.out.println(point1.equals(point2)); // 打印false

        System.out.println(point1 == point3); // 打印true         System.out.println(point1.equals(point3)); // 打印true

toString()：用来返回当前对象的字符串表示。

toString()方法的格式是：

        public String toString()

功能：返回当前对象的字符串表示，格式为“类名@对象的十六进制哈希码”。

许多类，如String、StringBuffer和包装类都覆盖了toString()方法，返回具有实际意义的内容。

例如：System.out.println(new Object().toString()); // 打印java.lang.Object@273d3c System.out.println(new Integer(10).toString()); // 打印10 System.out.println(new String(“Java”).toString());                          // 打印Java

           以上代码等价于：

System.out.println(new Object());

System.out.println(new Integer(10));

System.out.println(new String(“Java”));

finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

clone()：创建并返回此对象的一个副本

clone()方法的格式：

protected Object clone() throws CloneNotSupportedException

功能：创建并返回此对象的一个副本。

clone方法的返回类型为Object。

clone方法是protcted的，其他包的非子类无法调用它，所以通常需要对其进行覆盖，将该方法定义成public的:

getClass()：返回对象运行时所对应的类的表示，从而可得到相应的信息。

getClass()方法的格式是：

public final Class getClass()

功能：返回表示该对象的运行时类的java.lang.Class对象。

2. System类

（1）System类不能有子类，不能实例化。

（2）System类的定义：

public final class System {

        public static final InputStream in; // 标准输入流

        public static final PrintStream out; // 标准输出流

        public static final PrintStream err; // 标准错误输出流

        public static void setIn(InputStream in); // 重新设置标准输入流

        public static void setOut(PrintStream out); // 重新设置标准输出流

        public static void setErr(PrintStream err); // 重新设置标准错误输出流

        public static long currentTimeMillis(); // 返回当前时间(毫秒数)

        public static void arraycopy(Object src, int src_position, Object dst, int dst_position, int length); // 数组复制

        // 获取由key指定的系统属性值

        public static String getProperty(String key);

        // 设置由key指定的系统属性值

        public static String setProperty(String key, String value);

        public static void gc(); // 请求Java虚拟机运行垃圾收集程序

        public static void exit(int status); // 退出当前运行的Java虚拟机

}

例子：

import java.io.*;
public class Ex8_1 {
    public static void main(String[] args) throws IOException{
        char ch;
        System.out.println("请输入一个字符：");
        ch = (char)System.in.read();
        System.out.println("你输入了：" + ch);
        System.out.println("user.dir=" + System.getProperty("user.dir"));
        System.out.println("user.name=" + System.getProperty("user.name"));
        System.out.println("os.name=" + System.getProperty("os.name"));
        System.out.println("os.arch=" + System.getProperty("os.arch"));
        System.out.println("os.version=" + System.getProperty("os.version"));
        System.out.println("file.separator=" + System.getProperty("file.separator"));
        System.out.println("path.separator=" + System.getProperty("path.separator"));
    }
}

3. 日期类

（1） Date类和DateFormat类

Date：创建日期对象并获得日期

表示从GMT（格林尼治标准时间）1970年1月1日00:00:00这一刻开始的毫秒数，是以毫秒数来表示特定的日期。

Date date = new Date( );

System.out.println(date.getTime());

DateFormat：对日期进行格式化

public final String format(Date date)：将一个Date格式化为日期/时间字符串。

public Date parse(String source)：从给定字符串的开始分析文本，以生成一个日期。

public static final DateFormat getDateTimeInstance(int dateStyle, int timeStyle)：获得日期/时间格式化器，该格式化器具有给定格式化风格。

（2） Calender类

（2.1）Calendar类静态方法getInstance，用来获得一个Calendar对象

Calendar now =Calendar.getInstance( );

int year=now.get(Calendar.YEAR) ; //当年

int month=now.get(Calendar.DAY_OF_MONTH); //当月的天数

int minute=now.get(Calendar.MINUTE); //当前的分钟

Date date= now.getTime(); //当前时间

（2.2）更改日历字段的方法

set(int field, int value)：设置指定日历字段为给定值。

add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。

roll(int field,int amount)：向指定日历字段添加指定（有符号的）时间量

例子：打印2015年7月的日历表

import java.util.*;
public class Ex8_1 {
    public static void main(String[] args) {
        System.out.println("日  一  二  三  四  五  六");
        Calendar myCal = Calendar.getInstance();
        myCal.set(2016,7,1);
        int weekNo = myCal.get(Calendar.DAY_OF_WEEK)-1;
        String[] myWeek = new String[weekNo+31];
        for(int i=0; i<weekNo; i++){
            myWeek[i] = "  ";
        }

        for(int i=weekNo,n=1; i<weekNo+31; i++){
            if(n<=9){
                myWeek[i]=" "+String.valueOf(n);
            }
            else 	 myWeek[i]=String.valueOf(n);
            n++;
        }
        for(int i=0;i<myWeek.length; i++){
            if(i%7==0) System.out.println();
            System.out.print(myWeek[i]+"  ");
        }
    }
}

4. 集合框架

（1）集合框架和集合

Java语言的设计者对常用的数据结构和算法做了一些规范（接口）和实现（具体实现接口的类）。所有抽象出来的数据结构和操作（算法）统称为Java集合框架。
集合是指几种存放其他对象的一个对象,由两种类型构成，一个是Collection；另一个是Map。 Collection是所有集合的根接口，Map是所有键/值对映射的根接口。

（2）集合框架的数组和基本数组的区别

数组长度固定，集合的长度可变。
数组放的数据可以是基本类型和引用类型，集合只能是对象的引用。

（3） Collection接口

（3.1）集合类型的根接口

Collection表示一组对象，这些对象也称为Collection的元素。
三个子接口：List接口、Set接口和Queue接口。
Collection接口声明了集合中常用的一些通用方法。主要包括三类：基本方法、批量方法和数组方法。

（3.2）基本方法

boolean add(Object o) //向集合中添加指定元素o

boolean remove(Object o) //若集合中有指定元素o，则从集合中删除

int size() //返回集合中的元素个数

boolean isEmpty() //判断集合是否为空，若为空则返回true

boolean contains(Object o) //判断元素是否在集合中，若在则返回true

Iterator iterator() //返回该集合迭代器，可遍历集合中的元素

（3.3）批量方法

boolean containsAll(Collection c) //判断c中所有元素是否在集合中，

boolean addAll(Collection c) //向集合中添加c中所有元素

boolean removeAll(Collection c) //若集合中的元素在c中，从集合中删除

void clear() //删除集合中的所有元素

（3.4）数组方法

Object[] toArrary（） //将集合中的元素以数组形式返回

Object[] toArrary（Object[] a） //将集合中的元素转换成指定类型的数组

（4）List接口及实现类

（4.1） List接口的概念

实现线性表的数据结构。
List中可以包含重复元素。
List接口有两个通用的实现类，ArraryList和LinkedList。

（4.2） List接口的方法

定位访问。
查找。
迭代和返回子线性表。

（4.3） ArraryList类

通过数组实现的集合对象
随机访问的性能很好，插入、删除，则性能较差。
可添加null值。
ArraryList类的构造方法如下：

        ArraryList（） //构造一个初始容量为 10 的空线性表

        ArraryList（Collection c） //用集合c中的元素构造一个线性表

        ArraryList（int initialCapacity） //构造一个具有指定初始容量的空线性表

（4.4）LinkedList类

插入、删除，则性能较好，随机访问时间是线性的。
LinkedList类的构造方法如下：

        LinkedList（） //构造一个空链表

        LinkedList（Collection c）//用集合c中的元素构造一个链表

（5）Set接口及实现类

（5.1） Set接口的概念

Set接口对象类似于数学的集合概念。
Set接口与List接口对象最大的区别：重复元素（Set不包括），顺序。
Set接口是Collection的子接口，且没有定义新方法。
Set接口的常用实现类有TreeSet类、HashSet类和LinkedHashSet类。

（5.2） SortedSet接口和TreeSet类

SortedSet接口是一个Sorted类型的Set，实现该接口的类将按对象的天然顺序自动排序。
TreeSet类是实现了SortedSet接口的类。它有四个构造方法：

        TreeSet（）         //构造一个空的树集合

        TreeSet（Collection c） //用集合c中的元素构造一个树集合

        TreeSet（Comparator c） //空的树集合，按比较器c的规则排序

        TreeSet（SortedSet s） //用集合s中的元素构造一个树集合

（5.3） HashSet类的概念

HashSet类是按照哈希算法来存储对象引用的。
特点：最好的存取性能，存储的对象引用没有顺序，可向HashSet中添加一次null值。
HashSet类的构造方法有：

        HashSet（） //构造一个空的散列集合，加载因子(load factor)是0.75

        HashSet（Collection c） //用集合c中的元素构造一个散列集合

        //构造一个指定初始容量的散列集合

        HashSet（int initialCapacity）

        //构造一个散列集合，并指定初始容量和加载因子

        HashSet（int initialCapacity，float loadFactor）

（6）Queue接口及实现类

（6.1） Queue接口的概念

Queue接口是Collection的子接口，是以先进先出的方式排列其对象，称为队列。
Queue接口定义的方法：

        boolean add(E e) //将指定的对象e插入到队列中

        E remove() //返回队列头对象，并将其删除

        E element() //返回队列头对象，但不将其删除

        boolean offer(E e) //将指定的对象e插入到队列中

        E poll() //返回队列头对象，并将其删除

        E peek() //返回队列头对象，但不将其删除

（6.2） Queue接口的实现类

Queue接口有两个实现类：LinkedList类和PriorityQueue类。
PriorityQueue是优先队列，优先队列中的对象的顺序是根据对象的值排列的。
队头总是在调用remove()和poll()时被最先删除。

（7） Map接口及实现类

1. Map接口的概念

Map对象是用来存储关键字/值对的集合对象。
在Map对象存储的关键字和值都必须是对象，并要求关键字是唯一的，而值可以有重复。
Map是所有键/值对映射的根接口。Map不是Collection的的子接口。
Map接口的常用方法有：基本操作、批量操作和集合视图。

2. Map接口的实现类

Map接口的常用实现类有HashMap类、TreeMap类和Hashtable类。
HashMap类是基于哈希表的Map接口实现。
TreeMap类实现了SortedMap接口，SortedMap接口能保证Map中的各项按关键字升序排序。

5.题目

（1）单选题

1.1 在面向对象的软件系统中，不同类对象之间的通信的一种构造称为_______。

A.属性

B.封装

C.类

D.消息

1.2 向Collection中增加数据的方法是（）。

A.insert

B.add

C.append

D.concat

1.3 Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法不是Collection接口所定义的？( )

A.int size()

B.boolean containsAll(Collection c)

C.compareTo(Object obj)

D.boolean remove(Object obj)

1.4 要想在集合中保存没有重复的元素，并且按照一定的顺序排列，可以使用以下哪个集合？

A.LinkedList

B.ArrayList

C.HashSet

D.TreeSet

1.5 下列程序代码运行结果是：（）。

import java.util.*;    
public class Test {     
    public int hashCode() {        
         return 1;     
    }     
    public boolean equals(Object b) {        
        return true;    
   }    
    public static void main(String args[]) {        
        Set set = new HashSet();        
        set.add(new Test());        
        set.add(new String("ABC"));        
        set.add(new Test());        
        System.out.println(set.size());     
    }
}

A.1

B.2

C.3

D.4

1.6 下面哪个Map是排序的？

A.TreeMap

B.HashMap

C.Hashtable

D.WeakHashMap

E.LinkedHashMap

1.7 要想保存具有映射关系的数据，可以使用以下哪些集合：

A.ArrayList 、LinkedList

B.HashSet、TreeSet

C.TreeMap、HashMap

D.HashSet、HashMap *

1.8 使用Iterator时，判断是否存在下一个元素可以使用以下哪个方法？（）

A.next()

B.hash()

C.hasPrevious()

D.hasNext()

（2）程序填空题

2.1 数组列表

下列程序使用泛型机制创建一个数组列表对象，并向其添加三个元素，利用迭代器遍历该数组列表，请把程序补充完整。

import java.util.*; public class Main{

        public static void main(String[] args) {

                List<    String > al=new ArrayList<    String >();

                al.add("red");

                al.add("yellow");

                al.add("blue");

                ListIterator< String > listIter=al.listIterator();

                while(       listIter.hasNext()  3 分)

                        System.out.print( listIter.next() //3 分+" ");

        }

}

关于Iterator主要有三个方法：hasNext()、next()、remove()

hasNext:没有指针下移操作，只是判断是否存在下一个元素
next：指针下移，返回该指针所指向的元素
remove：删除当前指针所指向的元素，一般和next方法一起用，这时候的作用就是删除next方法返回的元素

2.2 学生按年龄排序、查找

有一学生类（Student），含有姓名（name）、年龄（age）属性，该类实现Comparable接口，要求重写compareTo方法，实现按照年龄的大小来确定两个学生的大小关系。

在链表中添加3个学生对象，通过Collections类的sort方法对链表中的学生按照年龄升序排序。输入第4个学生对象，并查找他（她）的年龄是否与链表中某个学生的年龄相同。

import java.util.*;

class Student implements Comparable <Student> {
    String name;
    int age;
    public Student(String name, int age) {

        this.name = name;
        this.age = age;
    }
    public int compareTo(Student stu) {   // 重写compareTo方法
        // 两个Student对象相等，当且仅当二者的age相等
        return this.age - stu.age;
    }
}

public class Test {
    public static void main(String args[ ]) {
        List <Student> list = new LinkedList <Student> (  );

        Scanner sc = new Scanner(System.in);

        System.out.println("输入三个学生的信息：");
        list.add( new Student( sc.next(), sc.nextInt() ) );
        list.add( new Student( sc.next(), sc.nextInt() ) );
        list.add( new Student( sc.next(), sc.nextInt() ) );

        Iterator <Student>  it = list.iterator();
        System.out.println("排序前，链表中的数据：");
        while ( it.hasNext( ) ) {        // 是否有下一个元素
            Student stu = it.next( );    // 取出下一个元素
            System.out.println( "姓名："+ stu.name + "，年龄：" + stu.age );
        }


        Collections.sort(list);//排序

        System.out.println("排序后，链表中的数据：");
        it = list.iterator( );
        while ( it.hasNext( ) ) {        // 是否有下一个元素
            Student stu = it.next( );    // 取出下一个元素
            System.out.println(  "姓名："+ stu.name + "，年龄：" + stu.age );
        }

        System.out.println("输入要查找的学生信息：");
        Student stu4 = new Student( sc.next(), sc.nextInt() );

        int index = Collections.binarySearch( list, stu4 );  //二分查找
        if ( index >= 0)
            System.out.println( stu4.name + "与链表中的"
                    + list.get(index).name + "年龄相同" );
        else
            System.out.println( "链表中的对象，没有一个与"
                    + stu4.name + "年龄相同的" );
    }
}

（3）函数题

3.1 jmu-Java-05集合-List中指定元素的删除

编写以下两个函数

//以空格(单个或多个)为分隔符，将line中的元素抽取出来，放入一个List
public static List<String> convertStringToList(String line) 
//在list中移除掉与str内容相同的元素
public static void remove(List<String> list, String str)

裁判测试程序：

public class Main {

    /*covnertStringToList函数代码*/   
        
    /*remove函数代码*/
        
     public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            List<String> list = convertStringToList(sc.nextLine());
            System.out.println(list);
            String word = sc.nextLine();
            remove(list,word);
            System.out.println(list);
        }
        sc.close();
    }

}

样例说明：底下展示了4组测试数据。

输入样例

1 2 1 2 1 1 1 2
1
11 1 11 1 11
11
2 2 2 
1
1   2 3 4 1 3 1
1

输出样例

[1, 2, 1, 2, 1, 1, 1, 2]
[2, 2, 2]
[11, 1, 11, 1, 11]
[1, 1]
[2, 2, 2]
[2, 2, 2]
[1, 2, 3, 4, 1, 3, 1]
[2, 3, 4, 3]

代码：

 public static List<String> convertStringToList(String line){
        List<String> s = new ArrayList<String>();
        String str = "";

        for(int i = 0; i < line.length(); i++){
            char c = line.charAt(i);
            if(c == ' '){
                if(!str.equals("")) s.add(str);
                str = "";
            }
            else{
                str+=c;
            }
        }
        if(!str.equals("")) s.add(str);//若str非空，则把元素添加进去。
        return s;
    }


    //在list中移除掉与str内容相同的元素
    public static void remove(List<String> list, String str){
        List<String> s = new ArrayList<String>();
        s.add(str);
        list.removeAll(s);
    }

注意： String str = ""; 里没有空格

（4）编程题

4.1 jmu-Java-01入门-开根号

使用逐步逼近法对给定数值x求开根号。

逐步逼近法说明：从0开始逐步累加步长值。

步长=0.0001，epsilon(误差)=0.0001

循环继续的条件：

平方值<x 且 |x-平方值| > epsilon

###说明与参考

数值输出保留6位小数，使用System.out.printf("%.6f\n")
求平方，参考Math.pow函数。
输入值<0时，返回Double.NaN

输入格式:

任意数值

输出格式:

对每一组输入，在一行中输出其开根号。保留6位小数

输入样例:

输出样例:

代码：

import java.util.*;
public class Main {
    public static void main(String []args){
        Scanner sc = new Scanner(System.in);

        double len = 0.0001;
        double e = 0.0001;

        while(true){
            double n = 0;
            double x = sc.nextDouble();
            if(x<0){
                System.out.println("NaN");
            }else{
                while( n*n<x && (x-n*n)>e ){
                    n+=len;
                }
                System.out.printf("%.6f\n",n);
            }
        }

    }
}

4.2 伪随机数

在java.util这个包里面提供了一个Random的类，我们可以新建一个Random的对象来产生随机数，他可以产生随机整数、随机float、随机double，随机long。Random的对象有两种构建方式：带种子和不带种子。不带种子的方式将会返回随机的数字，每次运行结果不一样。无论程序运行多少次，带种子方式构建的Random对象会返回一样的结果。

请编写程序，使用第一种方式构建Random对象，并完成下面输入输出要求。

输入格式:

在一行中输入3个不超过10000的正整数n,m,k。

输出格式:

在一行中输出以k为种子建立的Random对象产生的第n个0到m-1之间的伪随机数。

输入样例:

10 100 1000

输出样例:

代码：

import java.util.*;

public class Main {
    public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();

        Random s = new Random(k);
        int t = 0;
        for(int i=0; i<n; i++){
            t = s.nextInt(m);
        }
        System.out.println(t);
    }
}

Random.nextInt()方法: 生成一个随机的int值，该值介于[0,n)的区间，也就是0到n之间的随机int值，包含0而不包含n。

4.3 jmu-Java&Python-统计一段文字中的单词个数并按单词的字母顺序排序后输出

现需要统计若干段文字(英文)中的不同单词数量。
如果不同的单词数量不超过10个，则将所有单词输出(按字母顺序)，否则输出前10个单词。

注1：单词之间以空格(1个或多个空格)为间隔。
注2：忽略空行或者空格行。
注3：单词大小写敏感，即'word'与'WORD'是两个不同的单词。

输入说明

若干行英文，最后以!!!!!为结束。

输出说明

不同单词数量。
然后输出前10个单词（按字母顺序），如果所有单词不超过10个，则将所有的单词输出。

输入样例

Failure is probably the fortification in your pole
It is like a peek your wallet as the thief when you
are thinking how to spend several hard-won lepta
when you Are wondering whether new money it has laid
background Because of you, then at the heart of the
most lax alert and most low awareness and left it
godsend failed
!!!!!

输出样例

49
Are
Because
Failure
It
a
alert
and
are
as
at

代码：

import java.util.*;
public class Main{
    public static void main(String[] args){
        Set<String> words = new TreeSet<>();
        Scanner sc = new Scanner(System.in);

        while(true){
            String ss = sc.next();
            if(ss.equals("!!!!!"))
                break;
            else
                words.add(ss);
        }
        System.out.println(words.size());
        if(words.size()<10){
            for(String s: words)
                System.out.println(s);
        }
        else{
            int count=0;
            for(String s:words){
                if(count<10){
                    System.out.println(s);
                    
                }
                else
                    break;
                count++;
            }
        }

    }
}

for(String s: words){...}

1.创建名称为s 的String变量。
2.将words的第一个元素赋给s 。
3.执行重复的内容。
4.赋值给下一个元素s。
5.重复执行至所有的元素都被运行为止