ArrayList
package cn.myarraylist.domain;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @author 韦玉梅
*
*/
public class ArrayListTest_1 {
/**
* @param 定义功能,请除去ArraList集合中的重复元素
*/
public static void main(String[] args) {
List list= new ArrayList();
list.add("htfgvc");
list.add("abc");
list.add("123");
list.add("abc");
System.out.println(list);
System.out.println("----------------");
SingleElement(list);
System.out.println("----------------");
SinglElement2(list);
}
/**
* @param 删除重复元素
*/
private static void SingleElement(List list) {
for(int x=0;x<list.size()-1;x++){
Object object= list.get(x);
for(int y=x+1;y<list.size();y++){
if(object.equals(list.get(y)))
list.remove(y);
}
}
System.out.println(list);
}
/*
去除重复元素方式二
思路:
1、最后唯一性的元素很多,可以先定义一个容器用于存储这些唯一性的元素
2、对原有容器进行元素的获取,并到临时容器中去判断是否存在,容器本身就有这个功能,判断元素是否存在
3、存在就不存储,不存在就存储
4.遍历完原容器,临时容器中存储的就是唯一元素了
*/
/**
* @param 删除元素2
* @return
*/
private static void SinglElement2(List list) {
//定义一个 临时容器
List temp =new ArrayList();
//遍历原容器
for(Iterator iterator=list.iterator();iterator.hasNext();){
Object object=(Object)iterator.next();
//在临时容器中判断遍历元素是否存在
if(!temp.contains(object))
// 如果不存在,就存储到临时容器中
temp.add(object);
}
System.out.println(temp);
}
/*
public boolean equals(Object object) {
// 判断是否相同
if(this==object)
return true;
System.out.println(this+"........."+object);
if(!(object instanceof Person)){
throw new ClassCastException("类型错误");
}
Person person =(Person)object;
return this.name.equals(person.name) && this.age==person.age;
} */
}
package cn.myarraylist.domain;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author 韦玉梅
*
*/
public class ArrrayListDemo {
/**
* @param 向ArrayList中存储自定义对象 Person(name,age)
* 思路
* 1、描述:Person
* 2.定义容器对象
* 3、将Person对象存储到集合中
*/
public static void main(String[] args) {
// 创建ArrayList集合对象
ArrayList array1 =new ArrayList();
// 添加Person类型的对象
Person p1=new Person("张三",19);
Person p2=new Person("王五",20);
array1.add(p1);
array1.add(p2);
array1.add(new Person("王二",21));
System.out.println(array1);
System.out.println("-------------------------");
for(Iterator iterator=array1.iterator();iterator.hasNext();){
// iterator.next():取出的元素都有Object类型的
// System.out.println(iterator.next());
Person person= (Person) iterator.next();
System.out.println(person);
System.out.println("---------------");
System.out.println(person.getName()+":"+person.getAge());
}
// 取出元素
}
}
class Person{
private String name;
private int 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;
}
/**
*
*/
public Person() {
super();
// TODO Auto-generated constructor stub
}
/**
* @param name
* @param age
*/
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
LinkList
package cn.myarraylist.domain;
import java.util.LinkedList;
/**
* @author 韦玉梅
*
*/
public class LinkListDemo {
/**
* @param args
*/
public static void main(String[] args) {
// 创建一个链表对象
LinkedList list=new LinkedList();
// 添加方法
list.addFirst("123");
list.addFirst("abc");
list.add("dufrdhf");
list.addFirst("sdf");
// 获取元素
System.out.println(list.getFirst());
System.out.println(list.getFirst());
// 删除元素
System.out.println(list.removeFirst());
// 取出list中的所有元素
while (!list.isEmpty()) {
System.out.println(list.removeLast());
}
}
}
package cn.myarraylist.domain;
import java.util.LinkedList;
/**
* @author 韦玉梅
*/
public class LinkListDemo2 {
/**
* @param 练习
* 请通过LinkList实现一个堆栈,或者队列数据结构
* 堆栈:先进先出
* 队列:先进后出
*/
public static void main(String[] args) {
// 创建自定义的队列对象
MyQueue queue =new MyQueue();
// 添加元素
queue.myAdd("abc1");
queue.myAdd("abc2");
queue.myAdd("abc3");
queue.myAdd("abc4");
// 获取所有元素,先进先出
while (!queue.isNull()) {
System.out.println(queue.myGet());
}
}
}
class MyQueue{
private LinkedList linkedList;
public MyQueue() {
linkedList=new LinkedList();
}
public void myAdd(Object object) {
// 内部使用的是linkList的方法
linkedList.addFirst(object);
}
public Object myGet() {
return linkedList.removeFirst();
}
// 集合中是否有元素的方法
public boolean isNull() {
return linkedList.isEmpty();
}
}
Student.java
/**
*
*/
package cn.myarraylist.domain;
import javax.print.attribute.standard.Copies;
/**
* @author john5
*
*/
public class Student implements Comparable{
private String name;
private int age;
public String getName() {
return name;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
/**
* @param name
* @param age
*/
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// 覆盖hasCode(),根据对象的特点定义哈希值
@Override
public int hashCode() {
// System.out.println("123");
// return this.age;
return name.hashCode();
}
@Override
// 需要定义自身判断自身相同的依据,需要覆盖equals方法
public boolean equals(Object object) {
System.out.println(this+"\t"+object);
if(this==object)
return true;
if(! (object instanceof Student)){
throw new ClassCastException("类型错误");
}
Student student=(Student)object;
if(name.equals(student.name)){
return true ;
}else{
if(this.age == student.age){
return true ;
}
}
return false ;
}
@Override
/*
学生就具备了比较的功能,该功能是自然排序使用的方法
自然排序就年龄的升序排序为主
*/
public int compareTo(Object o) {
/*Student student=(Student) o;
if(this.age>student.age)
return 1;
if(this.age<student.age)
return -1;
return 0;*/
/*return 1;*/
/*
既然是同姓名同年龄是同一个人,视为重复元素,要判断的要素有两个
既然是按照年龄进行排序,所以先判断年龄,再判断姓名*/
Student student=(Student) o;
int temp=this.age-student.age;
return temp==0?this.name.compareTo(student.name):temp;
}
}
HashSet
/**
*
*/
package cn.myarraylist.domain;
import javax.print.attribute.standard.Copies;
/**
* @author john5
*
*/
public class Student implements Comparable{
private String name;
private int age;
public String getName() {
return name;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
/**
* @param name
* @param age
*/
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// 覆盖hasCode(),根据对象的特点定义哈希值
@Override
public int hashCode() {
// System.out.println("123");
// return this.age;
return name.hashCode();
}
@Override
// 需要定义自身判断自身相同的依据,需要覆盖equals方法
public boolean equals(Object object) {
System.out.println(this+"\t"+object);
if(this==object)
return true;
if(! (object instanceof Student)){
throw new ClassCastException("类型错误");
}
Student student=(Student)object;
if(name.equals(student.name)){
return true ;
}else{
if(this.age == student.age){
return true ;
}
}
return false ;
}
@Override
/*
学生就具备了比较的功能,该功能是自然排序使用的方法
自然排序就年龄的升序排序为主
*/
public int compareTo(Object o) {
/*Student student=(Student) o;
if(this.age>student.age)
return 1;
if(this.age<student.age)
return -1;
return 0;*/
/*return 1;*/
/*
既然是同姓名同年龄是同一个人,视为重复元素,要判断的要素有两个
既然是按照年龄进行排序,所以先判断年龄,再判断姓名*/
Student student=(Student) o;
int temp=this.age-student.age;
return temp==0?this.name.compareTo(student.name):temp;
}
}
package cn.myarraylist.domain;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.omg.CORBA.PRIVATE_MEMBER;
/**
* @author 韦玉梅
*
*/
public class HashSetDemo2 {
/**
*1、不允许存储重复元素,因为会发生查找的不确定性
*2、不保证存入和取出的顺序一致
*3、比数组的查询效率高
*4、用于存储元素和哈希值对应关系的容器称之为哈希表,冲突后,需要对元素进行进一步的判断,判断的是元素的内容,equals。
*当哈希算法算出的两个元素的值相同时,称为哈希冲突
*
*哈希表在判断元素是否相同,依据hasCode()方法,如果哈希重复(哈希值相同),
*再判断元素的equals方法,如果equals返回true,不存,返回false,存储!
*
* @param 练习:往hashset中存储学生对象(姓名 年龄)。 同姓名,同年龄视为同一人,不存
* 1、描述学生
* 2、定义容器
* 3、将学生对象存储到容器
*
* 发现存储了同姓名同年龄的学生是可以的
* 原因是每一次存储学生对象,都想调用hasCode()获取哈希值
* 但是调用的Object类中的hassCode,所以不同的对象,哈希值也不同
* 这就是同姓名同年龄存入的原因
*
* 解决:
* 需要根据学生对象自身的特点来定义哈希值
* 所以就需要覆盖hasCode方法
*
*/
public static void main(String[] args) {
// 创建容器对象
Set<Student> set =new HashSet<>();
// 创建学生对象
set.add(new Student("大黑",1));
set.add(new Student("Blue",5));
set.add(new Student("Bubble",1));
set.add(new Student("Blue",25));
set.add(new Student("Blue",5));
// 获取所有的学生
for(Iterator iterator=set.iterator();iterator.hasNext();){
Student student=(Student) iterator.next();
System.out.println(student.getName()+"\t"+student.getAge());
}
}
}
TreeSet
package cn.myarraylist.domain;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
* @author 韦玉梅
*
*/
public class TreeSetDemo {
/**
* @param TreeSet
* |--二叉树数据结构。TreeSet可以对元素进行排序 。不同步的
* 排序方式:需要元素具备比较功能,所以元素需要实现Comparab;e接口。覆盖CompareTo方法
* 如何保证元素的唯一性?
* 参考的就是比较方法的返回值是否是0,是,就是重复元素,不存。
* 排序方式:需要元素具备背胶功能,所以元素需要实现Comparable接口,覆盖CompareTo方法
*/
public static void main(String[] args) {
/*
初始化TreeSet集合明确一个比较器,实现Comparator接口,覆盖compare方法,将Comparator接口的对象,
作为参数传递给TreeSet集合的构造函数
比较器更为灵活,自然排序通常作为元素的默认排序
*/
Set set =new TreeSet(new ComparatorByName());//会自动排序 比较器
/*// 创建容器对象
Set set =new TreeSet();*/
/*// 创建对象
set.add("abc1");
set.add("eferf");
set.add("1bc3");
set.add("abc4");*/
// 创建学生对象
set.add(new Student("大黑",1));//java.lang.ClassCastException:
//因为学生要排序,就需要比较,而没有定义比较方法,无法完成排序
//比较add方法中使用的是comparable接口中的比较方法
set.add(new Student("Blue",5));
set.add(new Student("Bubble",1));
set.add(new Student("Blue",25));
set.add(new Student("Alue",5));//CompareTo会将Alue排到Blue前面
// 获取所有的学生
for(Iterator iterator=set.iterator();iterator.hasNext();){
// System.out.println(iterator.next());
Student student=(Student) iterator.next();
System.out.println(student.getName()+"\t"+student.getAge());
}
}
}