package javaStudy;
/**
*
* @author zhaocx1
*
*/
/*
* 枚举就是Vector特有的取出方式。
* 发现枚举和迭代器很像。
* 其实枚举和迭代是一样的。
* 因为枚举的名称以及方法的名称过长。
* 所以被迭代器取代了。
* 枚举郁郁而终了。
*/
import java.util.Enumeration;//导入集合中的枚举类包
import java.util.Vector;//导入集合中的Vector类包
public class VectorDemo {
public static void main(String[] args)// 主函数，整个函数的切入点
{
Vector v = new Vector();// 定义一个集合容器，用于存储集合中的元素
v.add("java01");// 添加元素
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration e = v.elements();// 通过枚举获取集合中的元素
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
}
package javaStudy;
/**
*
* @author zhaocx1
*
*/
import java.util.*;
/*
* Set:元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。
* --HashSet:底层数据结构是哈希表。
* --TreeSet:
*
* set集合的功能和collection的功能时一样。
*
*/
class SetDemo {//定义一个类
public int hashCode() {//定义一个方法：hashCode，用于判断HashSet集合中元素的唯一性
return 199;
}
}
public class SetCollection {
public static void main(String[] args) {//主函数，整个函数的切入点
SetDemo d1=new SetDemo();
SetDemo d2=new SetDemo();
sop(d1);
sop(d2);
HashSet hs = new HashSet();//定义一个集合容器，用于存储集合中的元素
sop(hs.add("java01"));//打印集合中的元素，Set集合中的元素没有顺序，元素不可以重复
sop(hs.add("java01"));
hs.add("java02");//添加元素
hs.add("java03");
hs.add("java03");
hs.add("java04");
Iterator it = hs.iterator();// 通过迭代器获取集合中的元素
while (it.hasNext()) {
sop(it.next());
}
}
public static void sop(Object obj) {// 将一个静态的打印方法封装到sop中，其它对象可以调用该方法
System.out.println(obj);
}
}
package javaStudy;
import java.util.HashSet;//导入集合中的HashSet类包
import java.util.Iterator;//导入集合中的迭代器类包
/**
*
* @author zhaocx1
*
*/
/*
* 往hashset集合中存入自定义对象 姓名和年龄相同为一个人，重复元素。
*
* hashSet是如何保证元素唯一性的？ 是通过元素的两个方法，hashcode和equals来完成的。
* 如果元素的hashcode值相同，才会判断equals是否为true。 如果元素的hashcode值不同，不会调用equals。
*/
class PersonP {// 定义一个PersonP类
private String name;// 私有化一个name属性
private int age;// 私有化一个age属性
PersonP(String name, int age) {// 对类进行构造函数，并将属性传递作为参数
this.name = name;// 调用本类属性
this.age = age;
}
public int hashCode() {// 定义一个方法用于获取hashCode值
System.out.println(this.name + "...HashCode");
return name.hashCode() + age;
}
public boolean equals(Object obj) {// 定义一个方法判断Object类是否包含Person类，如果包含向下转型，从而Object类可以接收Person类
if (!(obj instanceof PersonP))
return false;
PersonP p = (PersonP) obj;// 向下转型
return this.name.equals(p.name) && this.age == p.age;// 返回本类中的name和age属性
}
public String getName() {// 定义一个获取name属性的方法
return name;// 返回值为name
}
public int getAge() {// 定义一个获取age属性的方法
return age;// 返回值为age
}
}
public class HashSetTest {
public static void main(String[] args) {// 主函数，整个函数的切入点
HashSet hs = new HashSet();// 定义一个集合，用于存储集合中的元素
hs.add(new PersonP("a1", 11));// 添加元素
hs.add(new PersonP("a2", 12));
hs.add(new PersonP("a3", 13));
hs.add(new PersonP("a2", 12));
// hs.add(new Person("a4",14));
Iterator it = hs.iterator();// 获取迭代器，对集合中的元素进行迭代
while (it.hasNext()) {
PersonP p = (PersonP) it.next();
sop(p.getName() + "..." + p.getAge());// 输出打印姓名和年龄
}
}
public static void sop(Object obj) {// 将一个静态的打印方法封装到sop中，其它对象可以调用该方法
System.out.println(obj);
}
}
package javaStudy;
/**
*
* @author zhaocx1
*
*/
import java.util.*;
/*
*set:无序，不可以重复元素。
* HashSet:数据结构是哈希表，线程时非同步的。
* 保证元素唯一性的原理，判断元素的hashcode值是否相同。
* 如果相同，还会继续判断元素的equals方法，是否为true。
* TreeSet:可以对set集合中的元素进行排序。
* 底层数据结构是二叉树。
* 保证元素唯一性的依据，compareTo方法return 0.
*
* TreeSet排序的第一种方式：让元素自身具备比较性。
* 元素需要实现Comparable接口，覆盖compareTo方法。
* 这种方式也称为元素的自然顺序，或者叫做默认顺序。
*
* TreeSet排序的第二种方式：
* 当元素自身不具备比较性，或者具备的比较性不是所需要时。
* 这时就需要让集合自身具备比较性。
* 在集合一初始化时，就有了比较方式。
*记住：排序时，当主要条件相同时，一定要判断一下次要条件。
*
*/
/*
* 需求：往TreeSet集合中存储自定义对象学生。
* 想按照学生的年龄进行排序。
*
*/
class student implements Comparable// 该接口强制让学生具备可比较性。
{
private String name;//私有name属性
private int age;//私有age属性
student(String name, int age) {// 对类进行构造函数，并将属性传递作为参数
this.name = name;// 调用本类属性
this.age = age;
}
public int compareTo(Object obj) {//覆写Comparable中的CompareTo方法
return 1;
/*
* if (!(obj instanceof student)) throw new RuntimeException("不是学生对象");
* student s = (student) obj; System.out.println(this.name +
* "...compare..." + s.name); if (this.age > s.age) return 1; if
* (this.age == s.age) { return this.name.compareTo(s.name); }
*
* return -1; }
*/
}
public String setName(String name) {//设置一个name属性
return this.name=name;//返回本类属性
}
public int setAge(int age) {//设置一个age属性
return this.age=age;//返回本类属性
}
public String getName() {// 定义一个获取name属性的方法
return name;// 返回值为name
}
public int getAge() {// 定义一个获取age属性的方法
return age;// 返回值为age
}
}
public class TreeTest {
public static void main(String[] args) {//主函数，整个函数的切入点
TreeSet ts = new TreeSet();//定义一个容器，用于存储集合中的元素
ts.add(new student("lisi02", 22));//添加元素
ts.add(new student("lisi07", 20));
ts.add(new student("lisi09", 19));
ts.add(new student("lisi08", 19));
Iterator it = ts.iterator();
while (it.hasNext()) {//获取迭代器，用于获取集合中的元素
student stu = (student) it.next();
System.out.println(stu.getName() + "..." + stu.getAge());//输出打印姓名和年龄
}
}
}
package javaStudy;
import java.util.Comparator;//导入集合中比较器类包
import java.util.Iterator;//导入集合中的迭代器类包
import java.util.TreeSet;//导入集合中的TreeSet类包
/**
*
* @author zhaocx1
*
*/
/*
* 当元素自身不具备比较性，或者具备的比较性不是所需要的。 这时需要让容器自身具备比较性。
* 定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
*
* 当两种排序都存在时，以比较器为主。 定义一个类，实现Comparator接口，覆盖compare方法。
*/
class student1 implements Comparable {// 定义一个类实现一个
private String name;//私有name属性
private int age;//私有age属性
student1(String name, int age) {// 对类进行构造函数，并将属性传递作为参数
this.name = name;// 调用本类属性
this.age = age;
}
public int compareTo(Object obj) {
// return 1;
if (!(obj instanceof student1))
throw new RuntimeException("不是学生对象");
student1 s = (student1) obj;
// System.out.println(this.name +"...compare..." + s.name);
if (this.age > s.age)
return 1;
if (this.age == s.age) {
return this.name.compareTo(s.name);
}
return -1;
}
public String getName() {// 定义一个获取name属性的方法
return name;// 返回值为name
}
public int getAge() {// 定义一个获取age属性的方法
return age;// 返回值为age
}
}
// comparable里面是compareto方法，comparator里面是compare方法
class MyCompare implements Comparator {//TreeSet集合中对元素的第二种比较方法是：当元素自身不具备比较性时，自定义一个比较器，让元素具备比较性
public int compare(Object o1, Object o2) {
student1 s1 = (student1) o1;
student1 s2 = (student1) o2;
int num = s1.getName().compareTo(s2.getName());//先对name进行比较，当name相同的情况下，再对age进行比较
if (num == 0) {
if (s1.getAge() > s2.getAge())
return 1;
if (s1.getAge() == s2.getAge())
return 0;
return -1;
}
return num;
}
}
public class TreeTest2 {
public static void main(String[] agrs) {
TreeSet ts = new TreeSet(new MyCompare());//定义一个集合容器，用于存储集合中的元素，并将比较器作为参数传递到函数中
ts.add(new student1("lisi02", 22));//添加元素
ts.add(new student1("lisi007", 20));
ts.add(new student1("lisi09", 19));
ts.add(new student1("lisi08", 18));
Iterator it = ts.iterator();
while (it.hasNext()) {//通过迭代器获取集合中的元素
student1 stu = (student1) it.next();
System.out.println(stu.getName() + "..." + stu.getAge());//输出打印姓名和年龄内容
}
}
}
package javaStudy;
/**
*
* @author zhaocx1
*
*/
import java.util.*;
/*
* 练习：按照字符串长度排序。
*
* 字符串本身具备比较性，但是它的比较方式不是锁需要的。
* 这时就只能使用比较器。
*/
public class TreeTest3 {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new StrLenComparator());//定义一个集合容器，用于存储集合中的元素，并将比较器作为参数传递到函数中
ts.add("ab");//添加元素
ts.add("abc");
ts.add("abbd");
ts.add("aaa");
ts.add("absbf");
Iterator it = ts.iterator();//通过迭代器获取集合中的元素
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
//TreeSet集合中对元素的第二种比较方法是：当元素自身不具备比较性时，自定义一个比较器，让元素具备比较性
class StrLenComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1=(String)o1;
String s2=(String)o2;
//if(s1.length()>s2.length())
//return 1;
//if(s1.length()==s2.length())
// return 0;
// return -1;
//对元素的长度进行比较
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
扫一扫
3021
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
