Java学习笔记_09

一、

算法介绍（栈、队列、数组、链表、Hash、树）

栈和队列：

栈：先进后出

队列：先进先出

数组和链表

数组：查询快、增删慢

链表：增删快、查询慢

分为：

单向链表：数据+下一个元素的地址  
      双向链表  ：数据+下一个元素的地址+上一个元素的地址
 单向循环链表 ：最后一个元素存储的地址是第一个元素的地址值
 双向循环链表：存储的是两个地址，最后一个元素所存储的两个地址分别是上一个元素的地址和第一个元素的地址

二、

集合概念：

集合和数组的区别：数组不适应变化的需求,所有Java就提供了集合类供我们使用
数组：
1.长度固定
2.可以存储基本类型，也可以存储引用类型
3.存储元素类型一致
集合：
1.长度可变
2.只可以存储引用类型
3.可以存储多种类型

  为什么出现集合类？
   面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，我们就需要对这多个对象进行存储。

 而目前为止我们学习过的可以存储多个元素的东西是数组，但是呢，数组长度固定，不能适应变化的需求，所以，Java
 就提供了集合类供我们使用。

 Java提供了集合类供我们使用，而我们的需求可能是这样的：
  我要求我的元素是有序的，
   我要求我的元素是无序的，
   我要求我的元素是唯一的，
   我要求我的元素是可以重复的。
  为了满足不同的需求，Java就提供了不同的集合类。
  而这些集合类由于数据结构不同，才可以满足这些条件的。
  数据结构：存储元素的方式。
  而无论这些集合的结构是什么样子的，都是要装水的，所以，他们应该有共性的内容。
  通过不断的向上提取，最终会形成一个集合的继承体系图。
 

Collection （接口）：

是集合的顶层结构，定义了集合的共性功能。

 成员方法：(看到E我们先把它理解为Object即可)
   A:添加功能
   boolean add(Object obj):往集合中添加一个元素
   boolean addAll(Collection c):往集合中添加多个元素
   B:删除功能
   void clear():清空所有元素
   boolean remove(Object o):从集合中删除一个元素
   boolean removeAll(Collection c):从集合中删除另一个集合的元素
   C:判断功能
   boolean contains(Object o):判断集合中是否包含指定的元素
   boolean containsAll(Collection c):判断集合中是否包含另一个集合的元素
   boolean isEmpty():判断集合是否为空。
D:交集功能
  boolean retainAll(Collection c)
  E:迭代器(集合特有的遍历方式)
  Iterator iterator()
重点：Iterator的使用
A:使用步骤
B:迭代器原理
  F:长度功能
  int size():返回集合中元素的个数
 
  面试题：
  数组有length()吗?字符串有length()吗?集合有length()吗?
         G:集合转数组
Object[]toArray():把集合转成数组，然后遍历数组，其实就相当于遍历了集合。

例子：往集合里添加三个字符串并遍历。--->既是将集合转为数组，遍历

	public static void main(String[] args) {
		//创建集合
		//Collection c = new Collection();
		Collection<Comparable> c = new ArrayList<Comparable>();
		
		//boolean add(Object obj):往集合中添加一个元素
		c.add("hello");
		c.add("world");
		c.add("java");
		c.add(100);//集合中只能添加引用类型的数据，但是在这里为什么可以添加int类型的数据100呢？在这里进行了自动装箱
		Collection<String> c1 = new ArrayList<String>();
		c1.add("章子怡");
		c1.add("郭德纲");
		c.addAll(c1);
		Object[] objects = c.toArray();
		for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}
	}

迭代器

Iterator接口

  Iterator iterator()
   Object next():返回迭代的下一个元素,并移动指向的位置
   boolean hasNext():判断是否有元素
  
   NoSuchElementException:没有这样的元素异常。
   原因是：你已经获取到元素的末尾了，你还要继续获取元素，已经没有了，所以就报错了。
   解决方案：你不要再拿了。我哪知道什么就不拿了啊?怎么办呢?就应该在拿之前判断一下是否有元素。
  
  迭代器遍历集合：
   迭代器是依赖于集合而存在的。所以，要想得到迭代器对象，必须先有集合对象。
  
迭代步骤：
A:通过集合对象获取到迭代器对象
   B:通过迭代器对象的hasNext()方法判断是否有元素
   C:通过迭代器对象的next()方法获取元素

	public static void main(String[] args) {
		//学习的是集合的迭代器的遍历方式
		//创建一个集合
		Collection c = new ArrayList();
		//给集合中添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//将集合转换成迭代器对象之后进行遍历
		Iterator it = c.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
	}

迭代器图解：

List
(1)List集合的元素有序(存储和取出顺序一致),元素可重复


(2)List的特有功能：
A:添加功能
void add(int index,Object obj):在指定的位置添加元素
B:删除功能
Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
C:获取功能
get(int index) 返回列表中指定位置的元素。
D:替换功能
Object set(int index,Object obj)

(3)案例：
A:List存储字符串并遍历(迭代器,普通for)
B:List存储自定义对象并遍历(迭代器,普通for)

(4).List的倒序与洗牌
List中元素顺序可以被洗牌Collections.shuffle(list)
List中元素顺序可以被倒序Collections.reverse(list)
Collections.sort(list)对List元素排序（字母数字分别进行测试）

	public static void main(String[] args) {
		//创建List集合,List集合特点：元素的存入和取出的顺序一致
		List<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		void add(int index,Object obj):在指定的位置添加元素
		list.add(1, "php");
		
		Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
		Object remove = list.remove(1);
		System.out.println(remove);
		遍历集合
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}

LinkedList：

  LinkedList特有功能:
   public void addFirst(E e) 在第一个元素前增添一个元素
   public void addLast(E e)在最后一个元素后增添一个元素
 
  public E getFirst()
  public E getLast()
 
   public E removeFirst()删除第一个元素，打印会打印出此元素
   public E removeLast()删除最后一个元素，打印会打印出此元素




8.ArrayList与LinkedList的相同点与不同点  （面试题**）
相同点：有顺序的，元素可以重复
(1)ArrayList特点:
底层数据结构是数组,查询快,增删慢                                     
线程不安全,效率高
(2)LinkedList特点:
底层数据结构是链表,查询慢,增删快
线程不安全,效率高

List的三种遍历方法

1、迭代器

2、普通的for循环

3、增强for循环

	public static void main(String[] args) {
		//创建一个集合
		//list集合两个特点：1.元素存入和取出的顺序一致  2.元素可以重复
		List list = new ArrayList();
		
		//给集合中添加元素
		list.add("I");
		list.add("AM");
		list.add("HERE");
		Iterator it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
			
		}
		System.out.println("--------------");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
			
		}
		System.out.println("-------------");
		for (Object object : list) {
			System.out.println(object);
		}
		
	}

泛型：

(1)是一种把明确数据类型的工作推迟到创建对象或者调用方法的时候才去明确类型的特殊类型
(2)格式：
<数据类型>
默认情况下，是Object类型。
这里数据类型只能是引用类型。如果你看到写基本类型也行，其实这里使用了自动装箱。
(3)好处：
A:把运行时期问题提前到了编译时期
B:避免了强制类型转换
C:优化程序设计，解决了黄色警告线问题
(4)在哪里用?
一般来说就是在集合中用的多。
看API,如果类或者接口或者方法出现了<>说明这里就有泛型。

举例、先创建一个学生类、再把学生对象存入集合中，输出集合中对象的内容

	public static void main(String[] args) {
		//创建集合对象并加上泛型
		
		//创建学生对象
		Student s = new Student("刘德华", 50);
		Student s1 = new Student("张学友", 55);
		Student s2 = new Student("林志玲", 47);
		
		//创建集合对象并加上泛型
		List<Student> list = new ArrayList<Student>();
		
		//集合中添加元素
		list.add(s);
		list.add(s1);
		list.add(s2);
		
		//使用迭代器进行遍历
		Iterator<Student> it = list.iterator();
		while (it.hasNext()) {
			//取出迭代器中的元素
			Student ss = it.next();
			System.out.println(ss.getAge()+"  "+ss.getName());
		}
	}

增加泛型后，黄线警告解决了，而且输出时不用强制类型转换。

(5)泛型的概述(了解)
A:泛型类（把泛型定义在类上）

public class Generic<E>{}
B:泛型方法（把泛型定义在方法上）

public void show(E e){}
C:泛型接口（泛型定义在接口上）

public interface Inter<E>{}
(6)泛型通配符（先不进行讲解，后面会根据实例一一进行讲解）
<?> 不确定类型

<? extends E> 向上限定，E及其子类
<? super E> 向下限定，E及及其父类