集合框架

最新推荐文章于 2025-11-26 15:59:01 发布

最新推荐文章于 2025-11-26 15:59:01 发布 · 68 阅读

文章标签：

本文介绍了一款基于Java实现的学生信息排序与去重工具的设计与实现过程，包括生成指定数量的学生信息、按学分进行升序和降序排序、去除重复信息等功能。

排序和去重器：

package 排序与去重;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.JComboBox;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import netjava.lc.Set0728.Student;

public class SortListener implements ActionListener{

	//所要用到的属性
	JTextField field;
	JComboBox box;
	JTextArea text;
	int count;
	String command;
	Random ran = new Random();
	static List<Student> list = new ArrayList<Student>();
	
	public SortListener(JTextField field,JComboBox box,JTextArea text){
		this.field = field;
		this.box = box;
		this.text = text;
	}
	
	
	public void actionPerformed(ActionEvent e){
		count = Integer.valueOf(field.getText());
		command = (String)box.getSelectedItem();
		
		String s = e.getActionCommand();
		if("生成".equals(s)){
			list = createList(count);
			printElement(list);
			text.append("====================================="+"\n");
		}if("排序".equals(s)){
//			System.out.println("按钮：排序");
//			System.out.println("下拉框里面的值是："+command);
			if(command.equals("升序")){
				list = sort1(list);
				printElement(list);
			}if(command.equals("降序")){
				list = sort2(list); 
				printElement(list);
			}
			text.append("======================================="+"\n");
		}if("去重".equals(s)){
			list = modifyList(list);
			printElement1(list);
			text.append("====================================="+"\n");
		}
	}
	
	// 产生一个乱序的list集合
	public List<Student> createList(int count) {
		List list = new ArrayList();
		for (int i = 0; i < count; i++) {
			int j = ran.nextInt(5);
//			Student stu = new Student("学生" , 1,1);
			Student stu = new Student("学生" + (char)(j+65), j,1);
			list.add(stu);
		}
		return list;
	}
	
	// 输出list集合
	public void printElement(List<Student> list) {
		for (int i = 0; i < list.size(); i++) {
			// 我们已知List中放的是userInfo对象
			Student us = list.get(i);
			text.append("姓名：" + us.getName() + "    学分为：" + us.getScore() + "   身份证：" +us.getId()+"\n");
		}
	}
	
	

	// 升序排序的方法
	public List<Student> sort1(List<Student> list) {
		// List list = new ArrayList();
		for (int i = list.size(); i > 0; i--) {
			for (int j = 0; j < i - 1; j++) {
				// Student stu = list.get(i);
				if (list.get(j).getScore() > list.get(j + 1).getScore()) {
					Student stu1;
					stu1 = list.get(j);
					list.set(j, list.get(j + 1));
					// list.get(i) = list.get(i+1);
					list.set(j + 1, stu1);
				}
			}
		}
		return list;
	}
	

	// 降序排序的方法
	public List<Student> sort2(List<Student> list) {
		// List list = new ArrayList();
		for (int i = list.size(); i > 0; i--) {
			for (int j = 0; j < i - 1; j++) {
				// Student stu = list.get(i);
				if (list.get(j).getScore() < list.get(j + 1).getScore()) {
					Student stu1;
					stu1 = list.get(j);
					list.set(j, list.get(j + 1));
					// list.get(i) = list.get(i+1);
					list.set(j + 1, stu1);
				}
			}
		}
		return list;
	}
	
	// 去掉重复的方法
	public List<Student> modifyList(List<Student> list) {
		for (int i = 0; i < list.size() - 1; i++) {
			for (int j = i + 1; j < list.size(); j++) {
				if (list.get(i).getScore() == list.get(j).getScore()
						&& list.get(i).getName().equals(list.get(j).getName())
						&& list.get(i).getId() == list.get(j).getId()){
					list.get(j).type=1;
				}
			}
		}
		return list;
	}
	//去重的输出
	public void printElement1(List<Student> list){
		for (int i = 0; i < list.size(); i++) {
			// 我们已知List中放的是userInfo对象
			Student us = list.get(i);
			if(us.type==0){
				text.append("姓名：" + us.getName() + "    学分为：" + us.getScore() + "   身份证：" +us.getId()+"\n");
			}
		}
	}

}

package 排序与去重;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Insets;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class SortUI extends JFrame{

	public static void main(String[] args) {
		SortUI ui = new SortUI();
		ui.init();
	}
	
	public void init(){
		//基本设置
		this.setTitle("排序去重器");
		this.setSize(500, 300);
		this.setDefaultCloseOperation(3);
		this.setLocationRelativeTo(null);
		this.setLayout(new BorderLayout());
		this.setResizable(false);
		//添加组件
		JPanel panel = new JPanel();
		
		panel.setBackground(Color.GRAY);
		JTextArea text = new JTextArea();
		text.setEditable(false);
		JScrollPane pane = new JScrollPane(text);
		text.setMargin(new Insets(5, 5, 5, 5));
		this.add(panel,BorderLayout.WEST);
		panel.setPreferredSize(new Dimension(150, 300));
		this.add(pane,BorderLayout.CENTER);
		
		JLabel l1 = new JLabel("学生信息：");
		JLabel l2 = new JLabel("姓名      学分      身份证");
		JLabel l3 = new JLabel("个数：");
		JTextField field = new JTextField();
		JButton b1 = new JButton("生成");
		JLabel l4 = new JLabel("分类");
		String[] items = {"升序","降序"};
		JComboBox box = new JComboBox(items);
		JButton b2 = new JButton("排序");
		JButton b3 = new JButton("去重");
		
		panel.setLayout(null);
		panel.add(l1);
		l1.setBounds(0, 10, 100, 25);
		panel.add(l2);
		l2.setBounds(0, 35, 150, 25);
		panel.add(l3);
		l3.setBounds(0, 65, 55, 25);
		panel.add(field);
		field.setBounds(35, 65, 90, 25);
		panel.add(b1);
		b1.setBounds(45, 100, 60, 25);
		panel.add(l4);
		l4.setBounds(0, 135, 55, 25);
		panel.add(box);
		box.setBounds(45, 135, 60, 25);
		panel.add(b2);
		b2.setBounds(45, 170, 60,25);
		panel.add(b3);
		b3.setBounds(45, 200, 60, 25);
		
		this.setVisible(true);
		
		SortListener lis = new SortListener(field, box, text);
		b1.addActionListener(lis);
		b2.addActionListener(lis);
		b3.addActionListener(lis);
	}
	
}

package 排序与去重;

public class Student {

	private String name;
	private int score;
	private int id;
	public int type;

	// 构造方法
	public Student(String name, int score, int id) {
		this.name = name;
		this.score = score;
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	// 输出学生的基本信息
	public void showInfo() {
		System.out.println("姓名：" + name + "  学分为：" + score + "  身份证：" + id);
	}

	// 重写equals方法
	public boolean equals(Object obj) {
		System.out.println("比较方法");
		if (this == obj) {
			return true;
		}
		if (obj instanceof Student) {
			Student s = (Student) obj;// 向下转型
			if (this.id == s.id && this.name.equals(s.name)
					&& this.score == s.score) {
				return true;
			}
		}
		return false;
	}
}

  1.自定义队列是属于什么类型的数据结构?
                       线性结构
   2.如何实现自定义队列
                 数组的长度是固定的，无法直接操作内存，所以定义了一个类，让类封装了对数据的增，删，改，查的操作

java的集合框架类型
    1.Set
      1.无序的
      2.不能有重复的数据
      3.不能使用索引来获得数据
      4.如果要获得数据必须需要使用迭代器


    2.List
           实现的类：
    class AbstractList<E>
          此类提供 List 接口的骨干实现，以最大限度地减少实现“随机访问”数据存储（如数组）支持的该接口所需的工作。
    class AbstractSequentialList<E>
   此类提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作。
    class ArrayList<E>
          List 接口的大小可变数组的实现。
    class LinkedList<E>
          List 接口的链接列表实现。
    class Stack<E>
          Stack 类表示后进先出（LIFO）的对象堆栈。
    class Vector<E>
          Vector 类可以实现可增长的对象数组。

          AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList,
           RoleList, RoleUnresolvedList, Stack, Vector
    1.有序的
    2.操作方式类似
    3.是使用数组来实现


    3.Map
                   映射，一一对应
    键值对方式存储数据
    只要键值不同，那么值是可以相同的

    学号和学生，身份证和人


    不是Collection的子类,是一个与Collection于同一级别的接口

    4.队列
           自定义队列：自己定义队列里面的方法和属性
           接口Queue实现的类有: AbstractQueue, ArrayBlockingQueue, ArrayDeque,
               ConcurrentLinkedQueue, DelayQueue, LinkedBlockingDeque,
               LinkedBlockingQueue, LinkedList, PriorityBlockingQueue,
               PriorityQueue, SynchronousQueue