1.集合使用
集合主要是 set和list部分
现在我们来学习迭代器和list的基本使用及 set中的 hashset 的使用
首先来学习 迭代器的使用 接着学习list的使用 注意点和学习点都在 注释 结合代码 来更详细的介绍
public class colitrdemo {
public static void itmo(){//此函数是演示使用迭代器的使用
ArrayList<String>array=newArrayList<String>();
array.add("一号");
array.add("二号");
array.add("三号");
array.add("四号");
array.add("五号");
//普通获取所有的元素
for (int i = 0; i <array.size(); i++) {
System.out.println(array.get(i));
}
//迭代器获取
Iterator<String>itrtor=array.iterator();
while (itrtor.hasNext()) {//判断是否有下一个元素
System.out.println("while++++"+itrtor.next());
}
//迭代器获取优化 第二种方法 while 当循环完的时候 迭代器依然存在 而用 下面额for循环时 循环完之后 迭代器 消失 节省了内存 建议使用
for (Iterator<String>itrto=array.iterator() ;itrto.hasNext();) {
System.out.println("for++++"+itrto.next());
}
List<String> sub=array.subList(1, 3);//集合的获取 下标 从1开始 到三结束 包含1不包含三
System.out.println("sub-----"+sub);
}
public static void main(String[] args) {
linklistdemo();
}
//下面的 方法 我们来学习listiterator的使用 及使用过程出现的问题及注意特点
public static void listiterdemo(){
ArrayList<String> arraylis=new ArrayList<String>();
arraylis.add("list一号");
arraylis.add("list二号");
arraylis.add("list");
arraylis.add("list四号");
arraylis.add("list五号");
<span style="color:#ff0000;">//并发执行错误 并发修改产生错误 抛出并发修改异常
/*Iterator itrtor=arraylis.iterator();
while (itrtor.hasNext()){//判断是否有下一个元素
Object obj=itrtor.next();
if(obj.equals("list一号")){
arraylis.add("插入的");}//
System.out.println("while++++"+itrtor.next());
}*/</span>
//此时我们发现 程序不是正常执行 <span style="color:#663366;">原因是因为 我们将元素弄到了迭代器中两种都可以操作 而 迭代器操作时 集合又在操作 而迭代器时不知道的 所以产生并发作物
// 在迭代器时 若我们想修改集合 而迭代器的 方法有限 只能判断 取出删除不能添加 修改等操作
//所以 就需要使用 子接口 listiterator</span>
ListIteratoritrtor=arraylis.listIterator();
while (itrtor.hasNext()) {//判断是否有下一个元素
Object obj=itrtor.next();
if(obj.equals("list一号")){
itrtor.add("插入的");}//
else if(obj.equals("list")){
itrtor.set("list的修改");}//;
}
<span style="color:#ff0000;"> //此时的指针已经移到了 最后一个元素 所以我们现在来反向遍历</span>
//itrtor.hasPrevious() 判断是前一个有没有元素 反向遍历
while (itrtor.hasPrevious()) {//判断是否有下一个元素
Object obj=itrtor.previous();
System.out.println(obj);
}
}
<span style="color:#ff0000;"> /*********
* 下面我们来介绍一下list的特点
* arraylist 使用的是数组结构 查询速度快 修改慢 线程不同步 默认长度为10
* linkedlist的 链表结构 修改快 查找慢
* vector 底层数组 数据结构 线程同步 被arraylist替代
*/</span>
//下面我们来学习 vector
//下面的 方法 我们来学习listiterator的使用
public static void vectordemo(){
Vector vvv=new Vector();
vvv.add("11");
vvv.add("22");
vvv.add("33");
vvv.add("44");
Enumeration en=vvv.elements();
<span style="color:#ff0000;"> //枚举是 vector特有的取出方式</span>
<span style="color:#ff0000;">//和迭代是一样的 方法名过长 </span>
//
while(en.hasMoreElements()) {
System.out.println(en.nextElement());
}
}
//下面方法我们来学习 linkedlist
public static void linklistdemo(){
LinkedList list=new LinkedList();
list.addFirst("第一次");//头结点插入
list.addFirst("第二次");
list.addFirst("第三次");
list.addFirst("第四次");
list.addLast("第五次");
System.out.println(list);
/****
* 这里体现链表结构的特点
*/
}
}
2.我们来学习set的使用
public class colitset {
/**
* 学习set的使用元素无序 存入和取出的顺序不一定一致 set的属性 无序性
* hashset :底层数据结构是hash表 如何保证元素的唯一性
* 答：<span style="color:#ff0000;">通过元素的两个方法 hashcode 和equals来完成 hashcode是根据地址来判断 所以每次new 的结果都是不同的
* <span> </span> 所以用到hash表 我们穾复写方法
* <span> </span>如果元素的 hashcode相同 则判断equals是否为true
* <span> </span>如果hashcode不同则不再判断 equals 我们在
*<span> </span> hashsetdemodd 方法中验证这个问题</span>
*/
public static void hashsetdemof(){
HashSet hs=new HashSet();
hs.add("1");
hs.add("2");
hs.add("2");
hs.add("3");
hs.add("4");
System.out.println( "存入结果"+hs.add("4"));
Iterator iterator=hs.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
public static void hashsetdemodd(){<span style="color:#ff0000;">//此函数我们来存入 “人” 假设名字和年龄都一样时则不再存入</span>
HashSet hs=new HashSet();
hs.add(new person("a1",111));
hs.add(new person("b2",22));
hs.add(new person("b2",22));//<span style="color:#ff0000;">通过打印结果 此时我们发现是能存入的</span>
hs.add(new person("d4",44));
System.out.println(hs.add(new person("d4",44)));//存入结果为真 然而 我们不希望存入相同的信息
/****<span style="color:#ff0000;">
* 当person类中没有hashCode这个方法 注释掉
* 因为都是new出来的 所以 含有四个hash值 都不同 都存进去 所以没有执行equals方法</span>
*/
/***
<span style="color:#c0c0c0;"> </span><span style="color:#ff0000;">* 我们在person中添加hashCode这个方法
* 这时 再运行 添加值时 先判断hash值是否相同， hash值是相同时 在 进行 equals判断 equals 也相同则不添加
* hash不相同 则直接添加 不再进行判断equals函数 这两个函数都是复写 自动调用的</span>
*/
Iterator iterator=hs.iterator();
while (iterator.hasNext()) {
person p=(person)iterator.next();
System.out.println("遍历结果"+"编号为 "+p.getId()+" "+ " 判断 年龄为 - "+ p.getAge());
}
}
public static void main(String[] args) {
// TODO Auto-generated methodstub
hashsetdemodd();
}
}
class person{
private String id;
private int age;
public person(String id,int age){
this.id=id;
this.age=age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/***<span style="color:#ff0000;">
* 返回hash 值的方法
* 这里使每个的hash值都 相同
<span> </span>* 每次添加时都运行 hashcode方法 生成 hash值</span>
*/
public int hashCode( ){
System.out.println("用户 hash 值 "+this.id.hashCode());//打印hash值的加载
return id.hashCode();//String 数据类型 有hash方法 .hashCode()返回的就是hash值
}<span style="color:#ff0000;">//此时我们要防备一种情况
<span> </span>//就是自定义返回hash值相同的情况
<span> </span>//比如 a1+age = 3065+11；
<span> </span>//而<span> </span>a2+age = 3064+12 此时的hash值时相同的
<span> </span>//所以我们要通过小方法来避免这些错误 比如在年龄上乘山某一倍数</span>
public boolean equals(Object obj){
if(!(obj instanceof person)){//此时比较hash值不同则直接返回
<span> </span> System.out.println("hash值不相同 不再进行下面判断");
return false;
}
<span> </span> else{ hash相同则 进行下面的判断
<span> </span> System.out.println("hash值相同 进行下面判断");
person p=(person)obj;
<span> </span> System.out.println("用户编号+"+this.id+"--对象判断相等--"+p.id );
<span> </span>return this.id==(p.id)&&this.age==p.age;
}
}
}<span style="font-size:14px;">import java.util.*;
/*****
<span style="color:#ff0000;">Treeset；可以对set集合中的元素进行排序
排序 主要条件相同 一定判断 次要条件
底层数据结构是二叉树
保证元素唯一的依据
compareTo 方法的return
排序方式：1.元素自身具有比较性 元素实现compareto方法
这种方式也成为元素的的自然顺序 或者叫做默认顺序
2.元素不有比较性 或者具备的比较性也不是所需要的 这时就需要让集合自身具备比较性
在集合初始化的时候就有了比较方式</span>；
*/
/*
class treesetdemo
{
public static void main(String [] args)
{
TreeSet ts =new TreeSet();
ts.add("cbf");
ts.add("fdas");
ts.add("fedf");
ts.add("erac");
Iterator it =ts.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
输出结果为 //排序方式1 元素自身具有比较性
cbf
erac
fdas
fedf
}*/
class treesetdemo
{
public static void main(String [] args)
{
TreeSet ts =new TreeSet();
ts.add(new Student("a001",22));
ts.add(new Student("b002",33));
ts.add(new Student("c003",33));
ts.add(new Student("d003",11));
Iterator it =ts.iterator();
while (it.hasNext())
{
Student s=(Student)it.next();
System.out.println(s);
}
}
}
class Student implements Comparable //<span style="color:#ff0000;"> 该接口让 对象有比较性 假如不实现则会产生错误</span>
{ <span> </span>
private String name ;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}/<span style="color:#ff0000;">/实现比较的函数 </span>
public int <span style="color:#ff0000;">compareTo</span>(Object obj){
if(!(obj instanceof Student)) throw new RuntimeException("不是学生的对象");
Student s=(Student)obj;
System.out.println(this.name+"----compareto---"+s.name);
if(this.age>s.age)//<span style="color:#ff0000;">定义排排序规则 按照年龄的方式排序</span>
return 1;//当前对象
if(this.age==s.age)
{
this.name.compareTo(s.name);
}
return -1;
}
public String getName(){
return name;
}
public int getAge()
{
return age;
}
public String toString(){
return "name --"+getName() +"---age+++"+getAge();
}
}</span>import java.util.*;
/**
自定义比较器
两种排序都存在 以比较器为主
定义类 继承compare
*/
class treesetdemo2
{
public static void main(String [] args)
{
TreeSet ts =new TreeSet(new mycompare());//先执行比较器的排序 比较器排序要是结果相同再执行 类的compare
ts.add(new Student("a001",22));
ts.add(new Student("b002",33));
ts.add(new Student("c003",33));
ts.add(new Student("d003",11));
Iterator it =ts.iterator();
while (it.hasNext())
{
Student s=(Student)it.next();
System.out.println(s);
}
}
}
class Student implements Comparable // 该接口让 对象有比较性
{
private String name ;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public int compareTo(Object obj){
if(!(obj instanceof Student)) throw new RuntimeException("不是学生的对象");
Student s=(Student)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
this.name.compareTo(s.name);
}
return -1;
}
public String getName(){
return name;
}
public int getAge()
{
return age;
}
public String toString(){
return "name --"+getName() +"---age+++"+getAge();
}
}
class mycompare implements Comparator
{
public int <span style="color:#ff0000;">compare </span>(Object o1,Object o2){<span style="color:#ff0000;">//实际上也是调用了 compareto方法 来返回值</span>
Student s1=(Student)o1;
Student s2=(Student)o2;
return s1.getName().compareTo(s2.getName());
}
}下面再写一个例子 按照字符串的长度进行排序 使用比较器
import java.util.*;
class treesetdemo3
{
public static void main(String [] args)
{
TreeSet ts =new TreeSet(new stringcompare());
//TreeSet ts =new TreeSet(new mystringcompare());
ts.add("a0fgfhghfghfhh01");
ts.add("b0hhhh02");
ts.add("c00hhhhhh3");
ts.add("d003");
ts.add("adas");
Iterator it =ts.iterator();
while (it.hasNext())
{
String s=(String)it.next();
System.out.println(s);
}
}
}
class mystringcompare 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;
}
}
class stringcompare implements Comparator
{
public int compare (Object o1,Object o2){
String s1=(String)o1;
String s2=(String)o2;
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
//如果单纯这么写的话 只比较了长度 长度相同的就不会再存在
//所以还需要下面这句
//另外还需要注意字符串的此函数返回值是正数 但是不是1 所以我们不能判断 num==1
if(num==0){
return s1.compareTo(s2);
}
return num;
}
}我们使用到了两个compare 结合上面的例子我们来区分
- compareTo(Object o)方法是java.lang.Comparable<T>接口中的方法，当需要对某个类的对象进行排序时，该类需要实现Comparable<T>接口的，必须重写public int compareTo(T o)方法，
- compare(Object o1,Object o2)方法是java.util.Comparator<T>接口的方法，它实际上用的是待比较对象的compareTo(Object o)方法。
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
