java 新建一个set 赋值 java set创建

set

Set(接口)
无序(没有下标) 不重复

HashSet

// 使用 HashSet, 主要的用途是用来去重的
// 创建 HashSet
HashSet<String> set = new HashSet<>();
// 添加
boolean add = set.add("d"); // add == true
boolean add2 = set.add("d");// add == false 添加失败,不能重复
System.out.println(add);// true
System.out.println(add2);// false
System.out.println(set);// [d]

set.add("a");
set.add("b");
set.add("c");
set.add("a");
set.add("b");
set.add("c");
// 无序(不按照存进去的顺序打印),不重复
System.out.println(set);// [a, b, c, d]

// 创建一个 hashset 添加6个人 两两一样
// 通过重写对象类的 equals 和 hashCode 方法来达到 hashSet 去重的效果
HashSet<Person> persons = new HashSet<>();
persons.add(new Person("甲", 18));
persons.add(new Person("乙", 15));
persons.add(new Person("丙", 20));
persons.add(new Person("甲", 18));
persons.add(new Person("乙", 15));
persons.add(new Person("丙", 20));
for (Person person : persons) {
	System.out.println(person);
}

linkedHashSet

linkedHashSet(HashSet 的子类)
有序(怎么存进去就怎么取出来)

LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("w");
set.add("a");
set.add("n");
set.add("g");
set.add("l");
set.add("o");
set.add("n");
set.add("g");
System.out.println(set);//[w, a, n, g, l, o]

public static void main(String[] args) {
	LinkedHashSet<Integer> random = new LinkedHashSet<>();
	// 集合长度 < 10 的时候添加随机数
	while (random.size() < 10) {
		int randomNum = (int)(Math.random() * (20 - 1 + 1) + 1);
		random.add(randomNum);// 自动装箱
	}
	System.out.println(random);
}

public static void main(String[] args) {
	//  输入一个字符串,去掉其中重复字符
	System.out.println("请输入一个字符串:");
	Scanner scanner = new Scanner(System.in);
	String string = scanner.nextLine();
	char[] charArray = string.toCharArray();
	LinkedHashSet<Character> linkedHashSet = new LinkedHashSet<>();
	for (char c : charArray) {
		linkedHashSet.add(c);
	}
	System.out.println(linkedHashSet);
	scanner.close();
}

public static void main(String[] args) {
	//  利用set集合 去除ArrayList集合中的重复元素
	//  (操作原ArrayList)
	ArrayList<String> list = new ArrayList<>();
	list.add("a");
	list.add("a");
	list.add("a");
	list.add("b");
	list.add("b");
	list.add("c");
	list.add("c");
	list.add("d");
	list.add("d");
	// 创建 set 
	LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
	// 将 list 中所有元素,放入set 集合中去重
	linkedHashSet.addAll(list);
	// 清空原 list
	list.clear();
	// 把 set 中所有元素放入 list
	list.addAll(linkedHashSet);
	System.out.println(list);
	
}

TreeSet

TreeSet(内部实现二叉树)
无序 不重复 无下标
主要作用:由来排序

// 创建 TreeSet
TreeSet<Integer> set = new TreeSet<>();
set.add(1);
set.add(12);
set.add(15);
set.add(1);
set.add(4);
set.add(7);
set.add(19);
System.out.println(set);

// 系统提供一个接口 Comparable, 如果想通过TreeSet 来排序,就需要实现接口,编写排序的规则,系统才会按规则进行排序
TreeSet<Worker> set = new TreeSet<>();
set.add(new Worker("甲", 18));
set.add(new Worker("乙", 23));
set.add(new Worker("丙", 45));
set.add(new Worker("丁", 16));
for (Worker worker : set) {
	System.out.println(worker);
}

public class Worker extends Person implements Comparable<Worker>{

	public Worker() {
		super();
	}

	public Worker(String name, int age) {
		super(name, age);
	}

	// 实现接口中的唯一方法
	// 返回0时, set 中只有一个元素
	// 返回1时, 按存进去的顺序正序打印
	// 返回-1时, 按存进去的顺序倒序打印
	// TreeSet 按二叉树保存的
	// 要保存的数比它小 放在左边(返回负数)
	// 要保存的数比它打 放在右边(返回正数)
	// 要保存的数一样大 不存储
	// 打印升序(从小到大)
	/*
	 * 使用 TreeSet 排序的步骤
	 * 1.让 TreeSet 集合中保存的对象实现 Comparable 接口
	 * 2.实现 compareTo 方法
	 * 3.在 compareTo 方法中实现你要排序的规则
	 * (non-Javadoc)
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 */
	/*
	@Override
	public int compareTo(Worker o) {
		// 按年龄比较
		// return this.getAge() - o.getAge();
		// 按姓名比较
		// return this.getName().compareTo(o.getName());
	}
	*/
	/*
	 *  比较年龄
	 *  年龄一样看姓名
	 *  (non-Javadoc)
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 
	@Override
	public int compareTo(Worker o) {
		int index = this.getAge() - o.getAge();
		return index == 0 ? this.getName().compareTo(o.getName()) : index;
	}
	*/
	
	@Override
	public int compareTo(Worker o) {
		// 比较字符串长度
		int length = this.getName().length() - o.getName().length();
		// 长度一样比年龄
		int num = length == 0 ? this.getAge() - o.getAge() : length;
		// 年龄一样比姓名
		return num == 0 ? this.getName().compareTo(o.getName()) : num;
	}
}

public class Person {
	private String name;
	private int age;
	
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "[姓名:" + name + ", 年龄" + age + "]";
	}
	
	// 之后使用系统自动生成的 hashCode 和 equals 方法
	@Override
	public int hashCode() {
		// 31是个质数,只能被1和本身整除,乘法减少公约数
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	
	// 判断两个对象是否相同
	@Override
	public boolean equals(Object obj) {
		if (this == obj)// 如果两个对象地址一样
			return true;
		if (obj == null)// 如果传进来的对象是 null
			return false;
		if (getClass() != obj.getClass())// 如果两个对象不是一个类创建出来的
			return false;
		Person other = (Person) obj;// 向下转型(准备调用特有的方法)
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))// equals 使用的是 name 即字符串的比较
			return false;
		return true;
	}
	
	/*
	@Override
	public boolean equals(Object obj) {
		System.out.println();
		Person person = (Person)obj;
		return this.name.equals(person.getName()) && this.age == person.getAge();
	}
	
	// 重写 hashCode 方法
	// Set 集合在进行存储的时候
	// 当 hashCode 值相同时,会调用 equals 方法进行对比(同一个对象不存)
	// 当 hashCode 值不相同时,不会调用 equals 方法
	@Override
	public int hashCode() {
		final int num = 15;
		return this.name.hashCode() * num + this.age;
	}
	*/
	
	
	
}

/*
 *  使用比较器来排序 
 *  步骤:
 *  1.创建一个类实现 Comparator 接口
 *  2.实现接口中的方法并编写比较的规则
 *  3.把该类的对象传入 TreeSet 集合中
 */ 
TreeSet<String> set = new TreeSet<>(new KeepStringImpl());
set.add("asd");
set.add("asde");
set.add("asf");
set.add("asf");
set.add("asf");
set.add("a");
set.add("as");
set.add("w(ﾟДﾟ)w");
// 按字符串长度排序
System.out.println(set);

class KeepStringImpl implements Comparator<String>{
	// 比较的规则
	@Override
	public int compare(String o1, String o2) {
		int length = o1.length() - o2.length();
		int num = length == 0 ? o1.compareTo(o2) : length; 
		// 存与不存取决于这个方法的返回值
		// 返回不是0的任意数表示可以存相同的字符串
		return num == 0 ? ++num : num;
	}
}

//  键盘接收一个字符串, 程序对其中所有字符进行排序
//  要求保留重复的
TreeSet<Character> set = new TreeSet<>(new KeepCharacterImpl());
System.out.println("请输入字符串");
Scanner scanner = new Scanner(System.in);
String nextLine = scanner.nextLine();
char[] charArray = nextLine.toCharArray();
for (char c : charArray) {
	set.add(c);
}
System.out.println(set);
scanner.close();

class KeepCharacterImpl implements Comparator<Character>{
	@Override
	public int compare(Character o1, Character o2) {
		int num = o1.compareTo(o2);
		return num == 0 ? 1 : num;
	}
}

/*
 * 程序启动后, 可以从键盘输入接收多个整数, 
 * 直到输入quit时结束输入. 把所有输入的整数倒序排列打印.
 */
TreeSet<Integer> set = new TreeSet<>(new KeepIntImpl());
Scanner scanner = new Scanner(System.in);
while(true) {
	System.out.println("请输入整数(输入quit时结束输入):");
	String string = scanner.nextLine();
	if (string.equals("quit")) {
		break;
	}
	int num = Integer.parseInt(string);
	set.add(num);
}
System.out.println(set);
scanner.close();

class KeepIntImpl implements Comparator<Integer>{
	@Override
	public int compare(Integer o1, Integer o2) {
		int num = o1 - o2;
		return num == 0 ? 1 : -num;
	}
}

// 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)
// 录入的学生信息格式(姓名,语文成绩,数学成绩,英语成绩)
// 按照总分从高到低输出到控制台。输出学生所有信息
// 创建容器
TreeSet<Student> set = new TreeSet<>(new KeepImpl());
Scanner scanner = new Scanner(System.in);
// 循环输入5个学生
for (int i = 1; i < 6; i++) {
	System.out.println("请输入第" + i + "个学生信息(姓名,语文成绩,数学成绩,英语成绩):");
	// 接收信息
	String nextLine = scanner.nextLine();
	// 按逗号切割字符串
	String[] split = nextLine.split(",");
	// 把信息存入 Student 中
	Student student = new Student(split[0], Integer.parseInt(split[1]), Integer.parseInt(split[2]), Integer.parseInt(split[3]));
	set.add(student);
}
// 在集合中进行排序
for (Student student : set) {
	System.out.println(student);
}
scanner.close();

class KeepImpl implements Comparator<Student>{
	@Override
	public int compare(Student o1, Student o2) {
		int num = o1.getSumScore() - o2.getSumScore();
		return num == 0 ? 1 : -num;
	}
}

public class Student {
	private String name;
	private int chineseScore;
	private int mathScore;
	private int englishScore;
	private int sumScore;

	// 构造
	public Student() {
		super();
	}
	public Student(String name, int chineseScore, int mathScore, int englishScore) {
		super();
		this.name = name;
		this.chineseScore = chineseScore;
		this.mathScore = mathScore;
		this.englishScore = englishScore;
		sumScore = chineseScore + mathScore + englishScore;
	}
	
	// get/set
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}


	public int getChineseScore() {
		return chineseScore;
	}
	public void setChineseScore(int chineseScore) {
		this.chineseScore = chineseScore;
	}
	public int getMathScore() {
		return mathScore;
	}
	public void setMathScore(int mathScore) {
		this.mathScore = mathScore;
	}
	public int getEnglishScore() {
		return englishScore;
	}
	public void setEnglishScore(int englishScore) {
		this.englishScore = englishScore;
	}
	public int getSumScore() {
		return sumScore;
	}

	@Override
	public String toString() {
		return "[姓名" + name + ", 语文成绩:" + chineseScore + ", 数学成绩:" + mathScore
				+ ", 英语成绩:" + englishScore + ", 总分:" + sumScore + "]";
	}
}