Java第18天总结

Collection c1=new ArrayList();		//创建集合对象
		System.out.println(c1.isEmpty());		//判断集合是否为空，即个数是否为0
		
		//集合中不能保存基本类型，需要转换成对应的包装类
		c1.add(123);		//这里会激动装箱为Integer类型，然后发生多态转型为Object类型进行存储
		// 编译是为c1.add(Integer.valueOf(123));
		
		c1.add(new Integer(1));
		c1.add(new Collection_01());
		
		System.out.println(c1.size());		//查看该集合的个数
		System.out.println(c1.isEmpty());
		
		c1.remove(1);		//删除，会调用要删除元素的equals方法，因为这里自动装箱为Integer类型
		//Integer覆写了equals方法，所以可以把1删除
		
		A a=new A("张三");
		A a1=new A("张三");
		c1.add(a);
		c1.remove(a1);		//因为A是自定义类，所以这里删除要注意，在A类中是否覆写了equals方法，定义怎么算相等
		//如果没有覆写，此处删除a1，就等于无效代码，不会删除“张三”
		
		//把集合转换为数组，进行遍历
		Object[] arr=c1.toArray();
		for (Object object : arr) {
			System.out.println(object);
		}
		
		c1.clear();		//清空集合
		System.out.println(c1.size());

创建一个A类，里面有姓名的属性，并且A类中覆写了equals方法

class A{
	private String name;

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		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;
		A other = (A) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	public A(String name) {
		super();
		this.name = name;
	}

	@Override
	public String toString() {
		return "A [name=" + name + "]";
	}

Contains(数据) : 判断集合中是否包含某个元素

Remove(数据 ) : 删除指定元素

两个方法底层都会自动调用该对象的equals方法
因为不管是判断是否包含还是删除,都要先找到这个数据,而找到只能比较
但是集合中保存的都是引用类型,所以比较只能使用equals方法

所以如果存储的是自定义类型,就要考虑equals方法的覆写问题

 在面向对象编程里，迭代器模式是一种设计模式，是一种最简单也是最常见的设计模式。它可以让用户透过特定的接口巡防容器中的每一个元素而不用了解底层的实现。

获取该集合的迭代器对象：
Iterator it= 集合对象.iterator();
三个方法：1 boolean hasNext()：判断下面还有没有元素，如果有就返回true，没有就返回false
                  2 E next()：获取下一个元素，并指向下一个元素
                  3 remove()：删除当前指向的元素
这三个方法的使用也是按照该顺序

// Collection c1 = new ArrayList();
		//Collection c1 = new HashSet();
		Collection c1 = new linkedList();			//不管使用这三个哪一种都可以直接运行，因为Iterator不会管底层是什么
		c1.add(1);
		c1.add("abc");
		System.out.println(c1.contains(1));			//判断c1集合中是否包含1这个元素
		
		Iterator it=c1.iterator();		//创建迭代器
		while(it.hasNext()){		//遍历，终止条件为判断下面是否有元素，没有元素终止
			Object obj=it.next();		//获取并指向下一元素
			System.out.println(obj);
		}
		
		it=c1.iterator();		//使用完之后，想要再次使用，需要重新生成
		
		c1.add(2);
		c1.add(3);
		c1.remove(1);			//原则上在迭代器生成后不能有添加和删除的操作，如果有，就必须再次重新生成迭代器
		it=c1.iterator();

		while (it.hasNext()) {
			Object obj = it.next();
			System.out.println(obj);
			// c1.remove(obj);		使用迭代器的时候,不能更改集合个数,所以删除数据的时候不能使用集合的删除,应该使用迭代器的删除
			it.remove();
		}
		System.out.println(c1.size() + "----");

首先List的两个特点：
（1）有序：添加顺序和取出的顺序是一致的
（2）可重复：可以有重复的数据

ArrayList：底层是Object数组，随即查询和更改效率高，随机添加和删除效率低
linkedList：底层是一个双向链表，随机查询和更改效率低，随机添加和删除效率高

ArrayList底层是数组，下标从0开始，默认初始化容量为10，扩大容量为原始容量的1.5倍，并且默认容量是第一次添加数据的时候设置的，即new ArrayList的时候，数组长度是0；

1.5倍的计算方式为：长度+长度>>1        向右移位一次，即除以2

	// Vector 已经过时了,ArrayList是Vector的升级版,Vector是线程安全,而ArrayList是非线程安全的
		List list=new ArrayList();		//创建对象
		list.add(100);
		list.add(123);
		System.out.println(list);		//[100, 123]   里面覆写了toString方法
	

List list = new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);
		// add(E e)：尾部添加
		// add(int index , E e ) : 添加到指定位置
		// set(int index, E e ) : 更改指定位置上的元素值
		// remove(Object object) : 根据元素内容删除
		// remove(int index) : 根据索引删除
		// get(int index) : 获取指定位置的数据
		list.add(1,4);			//在下标1处添加   4这个元素  此时为1，4，2，3
		list.set(3, 33);			//更改下标3处的值， 也就是3的值改成了33  此时为1，4，2，33
		System.out.println(list.get(2));		//打印下标为2的值 ，即2
		list.remove(1);		//删除下标为1处的值，也就是删除了4		
		list.remove(new Integer(1));		//删除元素值为1的
		System.out.println(list);			//[2, 33]		

3种遍历方式

for (int i = 0; i  
3.2.4 排序 
List list=new ArrayList();
		list.add(4);
		list.add(1);
		list.add(2);
		list.add(14);
		list.add(6);
		Collections.sort(list);		//直接调用，只能默认是升序
		System.out.println(list);
 
3.3 linkedList 
和ArrayList操作一模一样
 
 
linkedList list = new linkedList();
		// add(E e ) : 尾部添加
		// add(int index , E e ) : 添加到指定位置
		// set(int index, E e ) : 更改指定位置上的元素值
		// remove(Object object) : 根据元素内容删除
		// remove(int index) : 根据索引删除
		// get(int index) : 获取指定位置的数据
		
		list.addFirst(1);		//首部添加
		
		list.push(11);		//首部添加
		
		list.offerFirst(111);		//首部添加 成功返回true
		
		list.addLast(2);		// 尾部添加
		
		list.offerLast(22);		// 尾部添加 成功返回true
		
		list.offer(222);		// 尾部添加 成功返回true
		
		list.add(1,4);			//在下标1处添加   4这个元素  此时为1，4，2，3
		list.set(3, 33);			//更改下标3处的值， 也就是3的值改成了33  此时为1，4，2，33
		System.out.println(list.get(2));		//打印下标为2的值 ，即2
		list.remove(1);		//删除下标为1处的值，也就是删除了4		
		list.remove(new Integer(1));		//删除元素值为1的
		System.out.println(list);			//[2, 33]
		
		for (int i = 0; i