迭代器和map的demo

/**
*1009笔记小结

1.键值对相当于json数组，大括号，单个元素是中括号；
countryMap.get(“CN”)// 根据索引获得值
key的类型一般用Integer，String；
2迭代器； 1》只能用keyset和values接收，map是键值对不能直接调用iterator方法；返回set,和collection接口
2》如果值是对象类型获得多个属性，比如it.next().getHealth，it.next().getStrain();不能这样写，否则 两次迭代不一致了，
3》如果增删修改时，foreach不能添加修改删除最后一个，会引起并发修改异常【fail-fast机制运行，此时线程不安全】。集合类型建议用迭代器；
需要用it.next();进行接收
3. //集合框架主要包含collection和map接口；其中collection接口包含list和set接口；
//添加时，先写方法，再在实现类中实例化有参构造，并调用方法；
4. //set集合存储引用类型对象时，如果不重写toString和equals，就不会过滤掉重复元素，因为new实例化了，改变了地址
5. LinkedList实例化对象, alist.addFist(Objiect o);有参数 ;alist.remove(); System.out.println(list.getFirst());//删除，或获得元素时，方法没有参数；
6. it=s.iterator();//使用while循环判断是否有下一个之前，必须通过键集/值集调用迭代方法进行迭代；无论是复制，删除查找都必须再次迭代，否则结果不出现。
7. Arraylist可以有参数
1)将这十个数存入HashSet集合中//Setset=new HashSet();
2)将这个HashSet集合转换成ArrayList集合.//，Listlist= new ArrayList<>(set);
8。使用迭代器的泛型也可以时键值对，通过map的keySet（）方法可以进行调用迭代器方法;foreach的变量亦可以用键值对类型作为变量类型；

• */
  package cn.kgc.tyl.test1001;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@NoArgsConstructor
@Data
public class Country {
private String fname,cname;
}

---

/**建立国家英文简称和中文全名间的键值映射，并通过key对value进行操作，应该如何实现数据的存储和操作呢？
Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作
最常用的实现类是HashMap
*/
package cn.kgc.tyl.test1001;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestCountry {
public static void main(String[] args) {
Map<String, String>cMap=new HashMap<String, String>();
cMap.put(“CN”, “中国”);
cMap.put(“Uk”, “英国”);//生成对象并存储；添加
System.out.println(cMap);//显示键值对
System.out.println(cMap.keySet());//显示键集
System.out.println(cMap.values());//【显示值集】
String country=cMap.get(“CN”);//获得指定元素的值【如果不存在返回null】
System.out.println(country);
System.out.println(cMap.size());//组数据
cMap.remove(“Uk”);//删除，无返回值,如果用输出语句，则返回值 结果：无输出
System.out.println(cMap.remove(“Uk”));// 结果：输出对应的值
System.out.println(cMap.size());
System.out.println(cMap.remove(“Uk”, “英国”)); //删除键值对，返回Boolean；
System.out.println(cMap.containsKey(“Uk”));//是否包含指定键/值
System.out.println(cMap+"\t"+cMap.size());
System.out.println(cMap.get(“CN”));//通过键获得值
System.out.println(cMap.containsKey(“CN”));//是否包含该键
cMap.put(“CNN”, “美国传媒”);
cMap.put(“CCTV”, “央视”);
System.out.println(“使用迭代器遍历键集值集”);
Setkeys=cMap.keySet();//返回键集，是set接口

 Iterator<String> it=keys.iterator();
 while (it.hasNext()) {
	System.out.println(it.next());
}
 System.out.println("使用迭代器遍历值集");
 Collection<String>values=cMap.values();//返回值集是collection接口
 Iterator<String>it2=values.iterator();
 while (it2.hasNext()) {
	System.out.println(it2.next());
}

}
}
/**
*
{Uk=英国, CN=中国}
[Uk, CN]
[英国, 中国]
中国
2
1
false
false
{CN=中国} 1
中国
true
使用迭代器遍历键集值集
CNN
CN
CCTV
使用迭代器遍历值集
美国传媒
中国
央视

• */
• **********************************************************************************************8
  package cn.kgc.tyl.test1009.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Dog {
private String name,strain;
private int age;

}

---

package cn.kgc.tyl.test1009.entity;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
//集合框架主要包含collection和map接口；其中collection接口包含list和set接口；
//添加时，先写方法，再在实现类中实例化有参构造，并调用方法；
//linkedlist特殊方法add/remove/get First/Last()方法
public class DogManager {
List dList=new ArrayList();
ListdList2=new LinkedList();
public void init() {
Collections.addAll(dList, new Dog(“ss”,“sss”,2),new Dog(“l”,“ll”,3));
Collections.addAll(dList2, new Dog(“ss”,“sss”,2),new Dog(“l”,“ll”,3));
}
public void showArray() {
System.out.println(“当前狗类信息”);
for (Dog dog : dList) {
System.out.println(dog);
}
}
public void showlinked() {
System.out.println(“当前狗类信息”);
for (Dog dog : dList2) {
System.out.println(dog);
}
}

public boolean add(Dog dog) {//实际中不能添加相同的先判断剔除，如果有不能添加
boolean flag=true;
for (int i = 0; i < dList.size(); i++) {
if (dList.get(i).getName().equals(dog.getName())) {

			return false;
	}
}

if (flag) {
dList.add(dog);
showArray();
}
return flag;
}
public boolean del(String name) {//判断是否存在

for (int i = 0; i < dList.size(); i++) {
	if (dList.get(i).getName().equals(name)) {
			dList.remove(i);
			showArray();
			return true;
	}
}

return false;

}

public boolean del2(String name) {//判断是否存在
Iteratorit=dList.iterator();
while (it.hasNext()) {
if (it.next().getName().equals(name)) {
it.remove();//查找到当前同名元素直接删除
return true;
}
}

}

---

package cn.kgc.tyl.test1009.test;

import java.util.Scanner;

import cn.kgc.tyl.test1009.entity.Dog;
import cn.kgc.tyl.test1009.entity.DogManager;

public class TestDog {
public static void main(String[] args) {
DogManager dm=new DogManager();
dm.init();
dm.showArray();
dm.showlinked();
Dog dog=new Dog(“大黄”,“田园犬”,9);
if (dm.add(dog)) {
System.out.println(“添加成功”);
}else{
System.out.println(“该对象已存在，无法添加”);
};
Dog dog2=new Dog(“大黄”,“田园犬”,9);
if (dm.add(dog2)) {
System.out.println(“添加成功”);
}else{
System.out.println(“该对象已存在，无法添加”);
};
System.out.println(“输入删除狗狗的名字”);
Scanner input = new Scanner(System.in);
String name=input.next();
if (dm.del(name)) {
System.out.println(“删除成功”);
}else {
System.out.println(“当前名字不存在，删除失败”);
}
System.out.println(“用迭代器输入删除狗狗的名字”);
Scanner input2 = new Scanner(System.in);
String name2=input.next();
if (dm.del2(name2)) {
System.out.println(“删除成功”);
dm.showArray();
}else {
System.out.println(“当前名字不存在，删除失败”);
}
}
}
}
/**
*
当前狗类信息
Dog(name=ss, strain=sss, age=2)
Dog(name=l, strain=ll, age=3)
当前狗类信息
Dog(name=ss, strain=sss, age=2)
Dog(name=l, strain=ll, age=3)
当前狗类信息
Dog(name=ss, strain=sss, age=2)
Dog(name=l, strain=ll, age=3)
Dog(name=大黄, strain=田园犬, age=9)
添加成功
该对象已存在，无法添加
输入删除狗狗的名字

• */

---

• package e20200622;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
*定义两个List接口，分别实例化成ArrayList和LinkedList，
*分别循环100000次的插入数操作(随机数0到1000000)，观察（运行看）或者
*计算（System.currentTimeMills方法统计时间
*）两个实现类的时长。

• /
  /*
  *@author 唐营利
  *@date 2020年6月23日
  *@time 下午6:13:28
• */
  public class Demo2 {
  public static void main(String[] args) {
  List list1=new ArrayList();
  List list2=new LinkedList();
  long t1=System.currentTimeMillis();//获取循环前当前时间格林尼治时间到现在
  for (int i = 0; i < 100000; i++) {
  list1.add((int)(Math.random()1000000));
  }
  long t2=System.currentTimeMillis();//获取循环结束当前时间也是第二个循环开始的时间
  for (int i = 0; i < 100000; i++) {
  list2.add((int)(Math.random()1000000));
  }
  long t3 =System.currentTimeMillis();//获取第二个循环前结束当前时间
  System.out.println(t2-t1);//Arraylist 第一个循环耗时
  System.out.println(t3-t2);//linkedlist第一个循环耗时
  }
  }
  /
  *如果插入相同的数字，时间相等，随机数ArrayList要插入的时间相对差些，添加删除相对慢。
• */

---

package e20200622;

import java.util.HashSet;
import java.util.Set;

public class Test3引用类型 {
public static void main(String[] args) {
Set set=new HashSet();
set.add(new Staff2(“tom”,10005D));
set.add(new Staff2(“jack”,10005D));
set.add(new Staff2(“tom”,10005D));
set.add(new Staff2(“zhao”,10005D));
set.add(new Staff2(“tom”,10005D));
System.out.println(set);
/**
*[Staff2 [职员姓名=zhao,工资=10005.0], Staff2 [职员姓名=tom,工资=10005.0], Staff2 [职员姓名=jack,工资=10005.0]]

 * 如果没有用ctrl+shift+s,进行hashcode和equals重写方法，就不会剔除相同元素，因为地址不同，又new了
 * [Staff2 [职员姓名=tom,工资=10005.0], Staff2 [职员姓名=zhao,工资=10005.0], Staff2 [职员姓名=jack,工资=10005.0], Staff2 [职员姓名=tom,工资=10005.0], Staff2 [职员姓名=tom,工资=10005.0]]

 * 
 * */

}
}
class Staff2{
private String name;
private Double money;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// @Override
// public int hashCode() {
// final int prime = 31;
// int result = 1;
// result = prime * result + ((money == null) ? 0 : money.hashCode());
// result = prime * result + ((name == null) ? 0 : name.hashCode());
// return result;
// }
// @Override
// public boolean equals(Object obj) {
// if (this == obj)
// return true;
// if (obj == null)
// return false;
// if (getClass() != obj.getClass())
// return false;
// Staff2 other = (Staff2) obj;
// if (money == null) {
// if (other.money != null)
// return false;
// } else if (!money.equals(other.money))
// return false;
// if (name == null) {
// if (other.name != null)
// return false;
// } else if (!name.equals(other.name))
// return false;
// return true;
// }
// public Double getMoney() {
// return money;
// }
// public void setMoney(Double money) {
// this.money = money;
// }
@Override
public String toString() {
return “Staff2 [职员姓名=” + name + “,工资=” + money + “]”;
}
public Staff2(String name, Double money) {
super();
this.name = name;
this.money = money;
}

}

---

package e20200622;

import java.util.LinkedList;
import java.util.List;

/**
*
5、任意封装一个实体类，创建LinkedList实例化对象，
练习具有队列特点的方法
（xxxFirst方法和xxxLast方法）

• */
  public class Test5 {
  public static void main(String[] args) {
  LinkedListlist=new LinkedList();
  list.add(1);
  list.add(2);
  list.add(34);
  list.add(4);
  list.add(5);
  list.add(56);
  System.out.println(list);

  list.addFirst(0);
  list.addLast(100);
  System.out.println(list);

  list.removeFirst();
  list.removeLast();
  System.out.println(list);

  System.out.println(list.getFirst());
  System.out.println(list.getLast());
  }
  }
  /**
  *增删首尾，查找首尾元素输出来
  *[1, 2, 34, 4, 5, 56]
  [0, 1, 2, 34, 4, 5, 56, 100]
  [1, 2, 34, 4, 5, 56]
  1
  56

---