Java泛型与集合框架/解析程序基本原理

泛型与集合框架

关于泛型与集合的博客

从Java 泛型初步介绍//进程的控制(20.5.19)往后

相关知识点

程序可能经常需要对链表按照某种大小关系排序，以便查找一个数据是否和链表中某个节点上的数据相等。Collections类提供的用于排序和查找的类方法如下：public static sort(List<E> list)该方法可以将list中的元素升序排列。
int binarySearch(List<T>list,T key,CompareTo<T>c)使用折半法查找list是否含有和参数key相等的元素，如果key链表中某个元素相等，方法返回和key相等的元素在链表中的索引位置(链表的索引位置从0开始)，否则返回一1。排序链表或查找某对象是否和链表中的节点中的对象相同，都涉及对象的大小关系。

String类实现了Comparable接口，规定字符串按字典顺序比较大小。如果链表中存放的对象不是字符串数据，那么创建对象的类必须实现Comparable接口，即实现该接口中的方法int compareTo(Object b)来规定对象的大小关系(原因是：sort（）方法在排序时需要调用名字是compareTo（)的方法比较链表中对象的大小关系，即Java提供的Collections类中的sort（）方法是面Comparable接口设计的）。

按身高排序例子

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;

class Student implements Comparable { //一个学生类
    private String name;
    private int height;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    @Override
    public int compareTo(Object o) {
        Student student = (Student) o;
        return (this.height - student.height);
    }
}

public class Example_1 {
    public static void main(String[] args) {
        Student[] students = new Student[3];    //3个学生
        students[0] = new Student("小明", 165);
        students[1] = new Student("小红", 160);
        students[2] = new Student("小刚", 170);
        LinkedList<Student> studentLinkedList = new LinkedList<>();
        for (int i = 0; i < students.length; i++) {
            studentLinkedList.add(students[i]);
        }
        Iterator<Student> iterator = studentLinkedList.iterator();  //用迭代器进行遍历
        System.out.println("排序前的顺序:");
        while (iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next.getName() + "的身高是:" + next.getHeight() + "cm");
        }
        System.out.println("排序后的顺序:");
        Collections.sort(studentLinkedList);	//将链表进行排序操作
        iterator = studentLinkedList.iterator();  //用迭代器进行遍历
        while (iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next.getName() + "的身高是:" + next.getHeight() + "cm");
        }
    }
}

相关知识点2

HashMap<K,V>对象采用散列表这种数据结构存储数据，习惯上称HashMap<K,V>对象为散列映射。散列映射用于存储“键/值”对，允许将任何数量的“键/值”对存储在一起。键不可以发生逻辑冲突，即不要两个数据项使用相同的键，如果出现两个数据项对应相同的键，那么，先前散列映射中的“键/值”对将被替换。

对于经常需要进行查找的数据可以采用散列映射来存储，即为数据指定一个查找它的关键字，然后按住“键/值”对，将关键字和数据一并存入散列映射中。

电话簿的例子

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.*;

class handleQuery implements ActionListener {
    Example_2 example_2;
    HashMap<String, String> hashMap;
    Scanner scanner = null;
    File file;

    public handleQuery() {
    }

    public handleQuery(Example_2 example_2) {
        this.example_2 = example_2;
        hashMap = new HashMap<String, String>();
        file = new File("C:\\Users\\Administrator\\Desktop", "电话簿.txt");
        try {
            scanner = new Scanner(file);
            scanner.useDelimiter("#");
            while (scanner.hasNext()) {
                String name = scanner.next();
                String mes = scanner.next();
                hashMap.put(name, mes);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        String key = example_2.jTextField.getText().trim();//去除前后空格
        Set<String> strings = hashMap.keySet(); //获取散列映射中的所有键
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            if (next.contains(key)) {    //如果该键里面包含其中的关键字
                String s = hashMap.get(next);
                example_2.jTextArea.append(next + ":" + "\n" + s + "\n");
            }
        }
    }
}

public class Example_2 extends JFrame {
    JTextField jTextField;
    handleQuery handleQuery;
    JButton jButton;
    JTextArea jTextArea;

    public Example_2() throws HeadlessException {
        setBounds(500, 500, 400, 400);
        setLayout(new FlowLayout());
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("电话簿");
        handleQuery = new handleQuery(this);
        jTextField = new JTextField(10);
        jTextField.addActionListener(handleQuery);
        jButton = new JButton("查找");
        jButton.addActionListener(handleQuery);
        jTextArea = new JTextArea(18, 30);
        add(new JLabel("姓名中含:"));
        add(jTextField);
        add(jButton);
        add(new JScrollPane(jTextArea));
        setVisible(true);
        validate();
    }

    public static void main(String[] args) {
        Example_2 example_2 = new Example_2();
    }
}

相关知识点3

TreeSet<E>类是实现Set<E>接口的类，它的大部分方法都是接口方法的实现。TreeSet<E>类创建的对象称作树集。树集采用树结构存储数据，当一个树集中的数据是实现Comparable接口类创建的对象时（即规定了对象的大小关系)，树结点中的数据会按存
放对象的“大小”顺序一层一层地依次排列，在同一层中的结点从左到右按从小到大顺序递增排列，下一层的都比上一层的小。理论上已经知道，把一个元素插入树集的合适位置要比插入数组或链表中的合适位置效率高。

树集不允许出现大小相等的两个结点.

详细Java树集//树映射//线程(20.5.24)

解析程序基本原理

解释程序是另一种语言处理程序，在词法、语法和语义分析方面与编译程序的工作质理基本相同，但是在运行用户程序时，它直接执行源程序，不产生源程序的目标程序。这类系统通常可以分为两部分：第一部分是分析部分，包括词法分析、语法分析和语义分析程序，经语义分析后把源程序翻译成中间代码，中间代码通常用逆波兰式表示；第二部分是解释部分，用来对第一部分产生的中间代码进行解释执行。

ps:逆波兰式（Reverse Polish notation，RPN，或逆波兰记法），也叫后缀表达式（将运算符写在操作数之后）

CET4P218

• nickel
• axis
• foresight
• layoff
• preach
• pirate
• dove
• automate
• naughty
• misfortune
• elevate