集合
package com.hu.javase.collection;
import java.util.ArrayList;
import java.util.Collection;
/*
关于java.util.Collection接口中常用的方法。
1、Collection中能存放什么元素？
没有使用“泛型”之前，Collection中可以存储Object的所有子类型。
使用了“泛型”之后，Collection中只能存储某个具体的类型。
集合后期我们会学习“泛型”语法。目前先不用管。Collection中什么都能存，
只要是Object的子类型就行。（集合中不能直接存储基本数据类型，也不能存
java对象，只是存储java对象的内存地址。）
2、Collection中的常用方法
boolean add(Object e) 向集合中添加元素
int size() 获取集合中元素的个数
void clear() 清空集合
boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false
boolean remove(Object o) 删除集合中的某个元素。
boolean isEmpty() 判断该集合中元素的个数是否为0
Object[] toArray() 调用这个方法可以把集合转换成数组。【作为了解，使用不多。】
*/
public class CollectionTest01 {
public static void main(String[] args) {
// 创建一个集合对象
//Collection c = new Collection(); // 接口是抽象的，无法实例化。
// 多态
Collection c = new ArrayList();
//测试Collection接口中常用的方法
c.add(1200);// 自动装箱(java5的新特性。),实际上是放进去了一个对象的内存地址。Integer x = new Integer(1200);
c.add(3.14); // 自动装箱
c.add(new Object());
c.add(new Student());
c.add(true);//自动装箱
//获取集合中元素的个数
System.out.println("集合中元素的个数是："+c.size());//5
//清空集合
c.clear();
System.out.println("集合中元素的个数是："+c.size());//0
//再向集合中添加元素
c.add("hello");//"hello"对象的内存地址放到了集合中
c.add("world");
c.add("浩克");
c.add("绿巨人");
c.add(1);
//判断集合中是否包含绿巨人
boolean flag = c.contains("绿巨人");
System.out.println(flag);//true
boolean flag2 = c.contains("绿巨人2");
System.out.println(flag2);//false
System.out.println(c.contains(1));//true
System.out.println("集合中元素的个数是："+c.size());//5
//删除集合中的某个元素
c.remove(1);
System.out.println("集合中元素的个数是："+c.size());//4
//判断集合是否为空（集合中是否存在元素）
System.out.println(c.isEmpty());//false
//清空集合
c.clear();
System.out.println("集合中元素的个数是："+c.size());//0
System.out.println(c.isEmpty());//true
c.add("abc");
c.add("def");
c.add(100);
c.add("helloworld");
c.add(new Student());
//转换成数组,使用不多，了解即可
Object[] objs = c.toArray();
for (int i = 0; i < objs.length; i++) {
//遍历数组
Object o = objs[i];
System.out.println(o);
}
}
}
class Student{
}
迭代器的集合原理
迭代原理：
package com.hu.javase.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
/*
关于集合遍历/迭代专题。（重点：五颗星*****）
*/
public class CollectionTest02 {
public static void main(String[] args) {
//注意：以下讲解的遍历/迭代方式，是所有Collection通用的一种方式
//在Map集合中不能用。在所有的Collection以及子类中使用
//创建集合对象
Collection c = new ArrayList();//后面的集合芜锁胃了，主要是看前面的Collection接口，怎么迭代/遍历
//添加元素
c.add("abc");
c.add("def");
c.add(100);
c.add(new Object());
// 对集合Collection进行遍历/迭代
// 第一步：获取集合对象的迭代器对象Iterator
Iterator it = c.iterator();
// 第二步：通过以上获取的迭代器对象开始迭代/遍历集合。
/*
以下两个方法是迭代器对象Iterator中的方法：
boolean hasNext()如果仍有元素可以迭代，则返回 true。
Object next() 返回迭代的下一个元素。
*/
while (it.hasNext()) {
//不管当初存进去什么，取出来统一都是Object
Object obj = it.next();
System.out.println(obj);
}
}
}
输出结果：
abc
def
100
java.lang.Object@1b6d3586 （这里存的是Object对象的地址）
package com.hu.javase.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class CollectionTest03 {
public static void main(String[] args) {
//创建集合对象
Collection c1 = new ArrayList();//ArrayList集合：有序可重复
//添加元素
c1.add(new Object());
c1.add(1);
c1.add(2);
c1.add(3);
c1.add(4);
c1.add(5);
c1.add(1);
//迭代集合
Iterator it = c1.iterator();
while (it.hasNext()){
//存进去是什么类型，取出来还是什么类型。只不过在输出的时候会转换成字符串
Object obj = it.next();
if (obj instanceof Integer){
System.out.println("Interger类型");
}
//因为这里的println会调用toString()方法
System.out.println(obj);
}
//HashSet集合：无序不可重复
Collection c2 = new HashSet();
//无序：指的是存进去和取出来的顺序不一定相同
//不可重复：存进去多个100，只能取出来一个100
c2.add(100);
c2.add(200);
c2.add(300);
c2.add(90);
c2.add(50);
c2.add(60);
c2.add(100);
Iterator it2 = c2.iterator();
while (it2.hasNext()){
System.out.println(it2.next());
}
}
}
输出结果：
java.lang.Object@1b6d3586
Interger类型
1
Interger类型
2
Interger类型
3
Interger类型
4
Interger类型
5
Interger类型
1
50
100
200
90
300
60
Collection的contains方法：
contains方法的源码：
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
package com.hu.javase.collection;
import java.util.ArrayList;
import java.util.Collection;
/*
深入Collection集合的contains方法：
boolean contains(Object o)
判断集合中是否包含某个对象o
如果包含返回true， 如果不包含返回false。
contains方法是用来判断集合中是否包含某个元素的方法，
那么它在底层是怎么判断集合中是否包含某个元素的呢？
调用了equals方法进行比对。
equals方法返回true，就表示包含这个元素。
*/
public class CollectionTest04 {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//向集合中存储元素
String s1 =(new String("abc"));
c.add(s1);
String s2 = new String("def");
c.add(s2);
//集合中元素的个数
System.out.println("元素的个数是"+c.size());
//新建对象String
String x = new String("abc");
//c集合中是否包含x？
System.out.println(c.contains(x));//true
System.out.println(x.equals(s1));
//这里是因为contains底层调用的是equals方法比较，而equals比较的是内容，不是对象
}
}
输出结果：
元素的个数是2
true
true
package com.hu.javase.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;
/*
测试contains方法
测试remove方法。
结论：存放在一个集合中的类型，一定要重写equals方法。
*/
public class CollectionTest05 {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
User u1 = new User("jack");
User u2 = new User("jack");
//加入集合
c.add(u1);
//判断集合中是否包含u2
//System.out.println(c.contains(u2));
//没有重写equals之前，这个结果是false
//重写equals方法之后，比较的时候会比较name
System.out.println(c.contains(u2));//true
Integer x = new Integer(10000);
c.add(x);
Integer y = new Integer(10000);
System.out.println(c.contains(y));//true
//因为Integer类的equals重写了
}
}
class User{
private String name;
public User(){}
public User(String name){
this.name = name;
}
// 重写equals方法
// 将来调用equals方法的时候，一定是调用这个重写的equals方法。
// 这个equals方法的比较原理是：只要姓名一样就表示同一个用户。
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
//如果名字一样表示同一个人。（不在比较对象的内存地址了，比较字符串内容）
return Objects.equals(name, user.name);
}
}
输出结果：
true
true