java__集合02

package cn.itcast.collelction;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Scanner;

/*

作业2：使用集合实现注册登陆功能，

第一步： 提示用户选择功能， A（注册）  B(登陆) 。 要求： 功能选择 的时候要忽略大小写。

注册：
1. 提示用户输入注册的账号(数字)与密码，如果输入账号已经存在集合中，提示用户重新输入。 注册完毕之后，把集合中的所有用户信息打印出来。(使用：toArrry()方法)
登陆：
提示用户输入登陆的账号与密码,如果账号与密码这个用户已经存在集合中，那么登陆成功，否则登陆失败。

*/
//用户
class User{

int id;  //账号

String password;  //密码

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public User(int id, String password) {
this.id = id;
this.password = password;
}

@Override
public boolean equals(Object obj) {
User user = (User)obj;
return this.id==user.id;
}

@Override
public String toString() {
return "{ 账号："+this.id+" 密码："+this.password+"}";
}
}

public class Demo1 {

static Scanner scanner = new Scanner(System.in);

static Collection users = new ArrayList(); //使用该集合保存所有的用户信息..

public static void main(String[] args) {

while(true){
System.out.println("请选择功能      A(注册 )    B(登陆)");
String option = scanner.next();
if("a".equalsIgnoreCase(option)){
reg();

}else if("b".equalsIgnoreCase(option)){
login();

}else{
System.out.println("你的选择有误,请重新输入");
}
}

}

public static void login() {
System.out.println("请输入账号：");
int id = scanner.nextInt();
System.out.println("请输入密码:");
String password = scanner.next();
//判断集合的用户是否存在该用户名与密码
//遍历集合的元素，查看是否存在该用户信息

boolean isLogin = false;    //定义变量用于记录是否登陆成功的信息  , 默认是没有登陆成功的
Iterator it = users.iterator();
while(it.hasNext()){
User user = (User) it.next();
if(user.id==id&&user.password.equals(password)){
//存在该用户信息，登陆成功...
isLogin = true;
}
}

if(isLogin==true){
System.out.println("欢迎登陆...");
}else{
System.out.println("用户名或者密码错误，登陆失败...");
}
}

public static void reg() {
//110  , 220
User user = null;
while(true){
System.out.println("请输入账号:");
int id = scanner.nextInt();  //220
user = new User(id,null);
if(users.contains(user)){  // contains底层依赖了equals方法。
//如果存在
System.out.println("该账号已经存在，请重新输入账号");
}else{
//不存在
break;
}
}

System.out.println("请输入密码：");
String password = scanner.next();
user.setPassword(password);
//把user对象保存到集合中
users.add(user);
System.out.println("注册成功!");
System.out.println("当前注册的人员："+users);
}

}

package cn.itcast.collelction;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*

------| Collection 单例集合的根接口
----------| List  如果是实现了 List接口的集合类，该集合类具备 的特点： 有序、可重复。
----------| Set   如果是实现了Set接口的集合类，该集合具备的特点： 无序，不可 重复。

Collection---迭代的方法：
toArray()
iterator()

迭代器的作用：就是用于抓取集合中的元素。

迭代器的方法：
hasNext()   问是否有元素可遍历。如果有元素可以遍历，返回true，否则返回false 。

next()    获取元素...

remove()  移除迭代器最后一次返回 的元素。

NoSuchElementException 没有元素的异常。
出现的原因： 没有元素可以被迭代了。。。

*/
public class Demo2 {

public static void main(String[] args) {
Collection c = new ArrayList();
c.add("狗娃");
c.add("狗剩");
c.add("铁蛋");
c.add("美美");

/*//遍历集合的元素------>方式一： 可以使用toArray方法。
Object[] arr = c.toArray(); // toArray()  把集合 的元素存储到一个 Object的数组中 返回。
for(int i = 0 ; i<arr.length ; i++){
System.out.print(arr[i]+",");
}

//要求使用iterator迭代器遍历。
*/

Iterator it = c.iterator();  //返回一个迭代器    疑问：iterator()方法返回的是一个接口类型，为什么接口又可以调用方法可以使用呢？  iterator 实际 上返回的是iterator接口的实现类对象。
/*
while(it.hasNext()){ // hasNext() 问是否有元素可以遍历。
System.out.println("元素："+ it.next()); //获取元素
}
*/

/*it.next();
it.next();
it.remove();  //删除迭代器最后一次返回的元素。
*/

//清空集合 的元素
while(it.hasNext()){
it.next();
it.remove();
}

System.out.println("集合的元素："+ c);

}

}

package cn.itcast.collelction;

interface  Money{

public void makeMoney();
}

class Worker implements Money{

@Override
public void makeMoney() {
System.out.println("工人在赚钱...");
}
}

class Student implements Money{

@Override
public void makeMoney() {
// TODO Auto-generated method stub

}

}

public class Demo3 {

public static void main(String[] args) {
Money  m = test();
m.makeMoney();

}

public static Money test(){

return new Worker();
}

}

package cn.itcast.list;

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

/*
List接口中特有方法：
添加
add(int index, E element)
addAll(int index, Collection<? extends E> c)
获取：
get(int index)
indexOf(Object o)
lastIndexOf(Object o)
subList(int fromIndex, int toIndex)

修改：
set(int index, E element)

List接口中特有的方法具备的特点： 操作的方法都存在索引值。

只有List接口下面的集合类才具备索引值。其他接口下面的集合类都没有索引值。

ctrl + shift + /  添加多行注释

ctrl  + shift + \  取消多行注释.
*/
public class Demo2 {

public static void main(String[] args) {
List list=  new ArrayList();
list.add("狗娃");
list.add("狗剩");
list.add("铁蛋");  //把元素添加到集合的末尾处。
list.add("狗娃");

/*
//添加方法
list.add(1, "赵本山"); // 把元素添加到集合中的指定索引值位置上。
List list2 = new ArrayList();
list2.add("本山");
list2.add("小沈阳");
list.addAll(2,list2); //把list2的元素添加到list集合指定索引值的位置上。
*/

/*
//      获取的方法
System.out.println("get方法获取元素："+list.get(1)); //根据索引值获取集合中的元素
使用get方法遍历集合的元素：
for (int i = 0; i < list.size() ; i++) {
System.out.print(list.get(i)+",");
}

System.out.println("找出指定元素第一次出现在集合中 的索引值："+ list.indexOf("本山"));
System.out.println("找指定的元素最后一次出现在集合中的索引值："+list.lastIndexOf("狗娃"));
List subList = list.subList(1, 3); //指定开始与结束的索引值截取集合中的元素。
System.out.println("子集合的元素是："+ subList);
*/
list.set(3, "赵本山"); //使用指定的元素替换指定索引值位置的元素。

System.out.println("集合的元素："+list);

}

}

package cn.itcast.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/*
迭代
listIterator()

ListIterator特有的方法：

添加：
hasPrevious()  判断是否存在上一个元素。
previous()    当前指针先向上移动一个单位，然后再取出当前指针指向的元素。

next();  先取出当前指针指向的元素，然后指针向下移动一个单位。

---------------------------

add(E e)   把当前有元素插入到当前指针指向的位置上。
set(E e)   替换迭代器最后一次返回的元素。

*/
public class Demo3 {

public static void main(String[] args) {
List list = new ArrayList();
list.add("狗娃");
list.add("狗剩");
list.add("铁蛋");
list.add("美美");

ListIterator it = list.listIterator(); //返回的是一个List接口中特有的迭代器
/*System.out.println("有上一个元素吗？"+ it.hasPrevious());
System.out.println("获取上一个元素："+it.previous());
it.next();
System.out.println("获取上一个元素："+ it.previous());

两个循环实现逆序输出
while(it.hasNext()){
it.next();
}

while(it.hasPrevious()){
System.out.println("元素："+ it.previous());
}

it.next();
it.next();
it.add("张三");
*/
it.next();
it.next();
it.set("张三");

System.out.println("集合的元素："+ list);

}

}

package cn.itcast.list;

import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;

/*
练习： 使用三种方式遍历集合的元素.
第一种： 使用get方法遍历。
第二种： 使用迭代器正序遍历。
第三种： 使用迭代器逆序遍历。

*/
public class Demo4 {

public static void main(String[] args) {
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");

System.out.println("======get方法遍历=======");
for(int i = 0 ; i<list.size() ; i++){
System.out.print(list.get(i)+",");
}

System.out.println("\r\n======使用迭代器正序遍历==========");
ListIterator it = list.listIterator();  //获取到迭代器
while(it.hasNext()){
System.out.print(it.next()+",");
}

System.out.println("\r\n======使用迭代器逆序遍历==========");
while(it.hasPrevious()){
System.out.print(it.previous()+",");
}

}

}

package cn.itcast.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/*

迭代器在遍历元素的时候要注意事项： 在迭代器迭代元素 的过程中，不允许使用集合对象改变集合中的元素 个数，如果需要添加或者删除只能使用迭代器的方法进行操作。

如果使用过了集合对象改变集合中元素个数那么就会出现ConcurrentModificationException异常。

迭代元素 的过程中: 迭代器创建到使用结束的时间。

*/

public class Demo5 {

public static void main(String[] args) {
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");

ListIterator it = list.listIterator();  //获取到迭代器
/*  while(it.hasNext()){
System.out.print(it.next()+",");
//it.add("aa"); // 把元素添加到当前指针指向位置，但不会迭代出新添加的数据，所以会跳过新添加的元素
list.add("aa");  // add方法是把元素添加到集合的末尾处的。会报错
//          list.remove("张三");
}*/

list.add("aa");
it.next();

System.out.println("\r\n集合的元素："+ list);
}

}

package cn.itcast.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/*

迭代器在变量元素的时候要注意事项： 在迭代器迭代元素 的过程中，不允许使用集合对象改变集合中的元素 个数，如果需要添加或者删除只能使用迭代器的方法进行操作。

如果使用过了集合对象改变集合中元素个数那么就会出现ConcurrentModificationException异常。

迭代元素 的过程中: 迭代器创建到使用结束的时间。

*/

public class Demo5 {

public static void main(String[] args) {
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");

ListIterator it = list.listIterator();  //获取到迭代器
/*  while(it.hasNext()){
System.out.print(it.next()+",");
//it.add("aa"); // 把元素添加到当前指针指向位置
list.add("aa");  // add方法是把元素添加到集合的末尾处的。
//          list.remove("张三");
}*/

list.add("aa");
it.next();

System.out.println("\r\n集合的元素："+ list);
}

}

package cn.itcast.list;

import java.util.ArrayList;
import java.util.Iterator;

/*

*/
class Book{

int id;

String name;// 名字

public Book(int id, String name) {
this.id = id;
this.name = name;
}

@Override
public String toString() {
return "{ 书号："+ this.id+" 书名："+ this.name+" }";

}

@Override
public boolean equals(Object obj) {
Book book =(Book)obj;
return this.id==book.id;
}

}

// 需求： 编写一个函数清除集合中重复元素。 如果书号是一样就视为重复元素。  要求： 遍历集合元素的时候必须使用迭代器。  get 迭代器

public class Demo7 {

public static void main(String[] args) {
ArrayList list=  new ArrayList();
list.add(new Book(110,"java编程思想"));
list.add(new Book(220,"java核心技术"));
list.add(new Book(330,"深入javaweb"));
list.add(new Book(110,"javas神书"));

ArrayList list2 = clearRepeat(list);
System.out.println("新集合的元素是："+ list2);
}

public static ArrayList  clearRepeat(ArrayList list){
//创建一个新的集合
ArrayList newList = new ArrayList();
//获取迭代器
Iterator it = list.iterator();
while(it.hasNext()){
Book book = (Book) it.next();  //从旧集合中获取的元素
if(!newList.contains(book)){
//如果新集合没有包含该书籍，那么就存储到新集合中
newList.add(book);
}
}
return newList;

}

}

package cn.itcast.list;

import java.util.Iterator;
import java.util.LinkedList;
/*

集合的体系：
----------| Collection  单列集合的根接口
----------------| List 如果实现了List接口的集合类，具备的特点： 有序，可重复。
--------------------| ArrayList   ArrayList 底层是维护了一个Object数组实现 的， 特点: 查询速度快，增删慢。
什么时候使用ArrayList: 如果目前的数据是查询比较多，增删比较少的时候，那么就使用ArrayList存储这批数据。  比如 ：高校的 图书馆

--------------------| LinkedList   LinkedList底层是使用了链表数据结构实现的，  特点： 查询速度慢，增删快。

--------------------| Vector(了解即可)

----------------| Set  如果实现了Set接口的集合类， 具备的特点： 无序，不可重复。

Linkedlist特有的方法：
1：方法介绍
addFirst(E e)
addLast(E e)

getFirst()
getLast()

removeFirst()
removeLast()

2：数据结构
1：栈 （1.6）  : 主要是用于实现堆栈数据结构的存储方式。
先进后出
push()
pop()
2：队列（双端队列1.5）： 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。
先进先出
offer()
poll()

3：返回逆序的迭代器对象
descendingIterator()   返回逆序的迭代器对象
*/

public class Demo8 {

public static void main(String[] args) {
LinkedList list= new LinkedList();
list.add("张三");
list.add("李四");
list.add("王五");
/*
list.addFirst("狗娃"); //把元素添加到集合的首位置上。
list.addLast("狗剩");  //把元素添加到集合的末尾处。

System.out.println("获取集合中首位置的元素:"+list.getFirst());
System.out.println("获取集合中末尾的元素："+ list.getLast());

System.out.println("删除集合中的首位置元素并返回："+ list.removeFirst());
System.out.println("删除集合中的末尾素并返回："+ list.removeLast());

list.push("狗娃");   //将该元素插入此集合的开头处。
System.out.println("删除集合的首元素："+list.pop()); // 移除并返回集合中的第一个元素

list.offer("狗剩");
System.out.println("删除集合的首元素: "+list.poll());

System.out.println("集合中的元素："+ list);
*/
Iterator  it = list.descendingIterator();
while(it.hasNext()){
System.out.println(it.next());
}

}

}

package cn.itcast.list;

import java.util.LinkedList;

/*
1：栈 （1.6）  : 主要是用于实现堆栈数据结构的存储方式。
先进后出
push()
pop()
2：队列（双端队列1.5）： 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。
先进先出
offer()
poll()

机试题目： 使用LinkedList实现堆栈数据结构的存储方式与队列的数据结构存储方式。
*/

// 使用LinkedList模拟堆栈的数据结构存储方式
class StackList{

LinkedList list;

public StackList(){
list = new LinkedList();
}

//进栈
public void add(Object o){
list.push(o);
}

//弹栈 : 把元素删除并返回。
public Object pop(){
return list.pop();
}

//获取元素个数
public int size(){
return list.size();
}

}

//使用LinkedList模拟队列的存储方式
class TeamList{

LinkedList list;

public TeamList(){
list = new LinkedList();
}

public void add(Object o){
list.offer(o);
}

public Object remove(){
return list.poll();
}

//获取元素个数
public int size(){
return list.size();
}

}

public class Demo9 {

public static void main(String[] args) {
TeamList list=  new TeamList();
list.add("李嘉诚");
list.add("马云");
list.add("王健林");

int size = list.size();
for(int i = 0 ; i<size ; i++){
System.out.println(list.remove());
}

}
}

package cn.itcast.list;

import java.util.LinkedList;
/*
需求： 使用LinkedList存储一副扑克牌，然后实现洗牌功能。

52张

一张扑克牌： 花色  点数。  梅花6

class Poker{

String color;

String num;
}

String[] colors = {"黑桃","红桃","梅花","方块"};

String[] nums = {"A","2"}

*/

package cn.itcast.list;

import java.util.LinkedList;
import java.util.Random;

/*
需求： 使用LinkedList存储一副扑克牌，然后实现洗牌功能。

*/
//扑克类
class Poker{

String  color; //花色

String num; //点数

public Poker(String color, String num) {
super();
this.color = color;
this.num = num;
}

@Override
public String toString() {
return "{"+color+num+"}";
}
}

public class Demo2 {

public static void main(String[] args) {
LinkedList pokers = createPoker();
shufflePoker(pokers);
showPoker(pokers);
}

//洗牌的功能
public static void shufflePoker(LinkedList pokers){
//创建随机数对象
Random random = new Random();
for(int i = 0 ; i <100; i++){
//随机产生两个索引值
int index1 = random.nextInt(pokers.size());
int index2 = random.nextInt(pokers.size());
//根据索引值取出两张牌，然后交换两张牌的顺序
Poker poker1 = (Poker) pokers.get(index1);
Poker poker2 = (Poker) pokers.get(index2);
pokers.set(index1, poker2);
pokers.set(index2, poker1);
}

}

//显示扑克牌
public static void showPoker(LinkedList pokers){
for(int i = 0 ; i<pokers.size() ; i++){
System.out.print(pokers.get(i));
//换行
if(i%10==9){
System.out.println();
}
}

}

//生成扑克牌的方法
public static LinkedList createPoker(){
//该集合用于存储扑克对象。
LinkedList list = new LinkedList();
//定义数组存储所有的花色与点数
String[] colors = {"黑桃","红桃","梅花","方块"};
String[] nums = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
for(int i = 0 ; i < nums.length ; i++){
for(int j = 0 ; j<colors.length ; j++){
list.add(new Poker(colors[j], nums[i]));
}
}
return list;
}

}

package cn.itcastset;

import java.util.Iterator;
import java.util.TreeSet;
/*
需求：将字符串中的数值进行排序。
例如String str="8 10 15 5 2 7"; ---->   "2 5 7 8 10 15"
*/

public class Demo8 {

public static void main(String[] args) {
String str="8 10 15 5 2 7";
String[] datas = str.split(" ");

TreeSet tree = new TreeSet();
for(int i = 0 ; i<datas.length ; i++){
tree.add(Integer.parseInt( datas[i])); // 字符串转int类型数据是需要使用Integer.parseInt()
}

//遍历treeSet的元素拼接成对应的字符串
Iterator it = tree.iterator();
while(it.hasNext()){
System.out.print(it.next()+" ");
}

}

}