java学习（10）

java学习（10）

这篇写关于数据结构和一些常用集合，以及介绍泛型。

1.数据结构：

就是存储数据的方式.这里简单的介绍一下各种数据结构的特点，具体的不做详细叙述，在集合了涉及到时会进行说明，具体分析。

（1）栈：先进后出

（2）队列：先进先出

（3）数组：查询快，增删慢

（4）链表：通过一个链子把多个结点（元素）连接起来，由数据和地址组成的一个元素，节点本身必须有一个地址值（就是下一个元素的地址值）  特点：查询慢，增删快

链表分为：

1）单向链表：数据+下一个元素的地址

2）双向链表 ：数据+下一个元素的地址+上一个元素的地址

3）单向循环链表 ：最后一个元素存储的地址是第一个元素的地址值

4）双向循环链表：存储的是两个地址，最后一个元素所存储的两个地址分别是上一个元素的地址和第一个元素的地址

5）hash:哈希，把任意长度的输入（又叫做预映射， pre-image）通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的信息压缩到某一固定长度的消息摘要的函数。

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

出现集合类的原因：
  java是一种面向对象的语言，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，需要对这多个对象进行存储。而数组长度固定，不能适应变化的需求，所以Java就提供了集合类供我们使用。
由于需求的不同，Java提供了不同的集合类：

这里写几个最常用的集合：

（1）接口：Collction：层次结构中的根接口。Collection 表示一组对象

（2）Collction的子接口：List，Set

（3）List的几个常用实现类：ArrayList,LinkedLsit,Vector

（4）Set的几个常用实现类：HashSet，TreeSet

3.常类的具体介绍

3.1集合部分：
1.Collection
是集合的顶层结构，定义了集合的共性功能。可以存储对象，这些对象也被称为元素。

Collection是一个接口，是不能被实例化的，所以用多态的方法，指向一个实现类对象，首先定义一个Collection集合，方便之后的代码编写：

//创建collection这个接口的对象

Collection c = new ArrayList();

//5个字符串元素

String s1 = "to";

String s2 = "be";

String s3 = "or";

String s4 = "not";

String s5 = "to";

String s6 = "be";

成员方法：
1）添加功能
boolean add(Object obj):往集合中添加一个元素

boolean addAll(Collection c):往集合中添加多个元素

示例:

//boolean add(Object obj):往集合中添加一个元素
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(s5);
c.add(s6);
//boolean addAll(Collection c):往集合中添加多个元素
//创建一个新的集合
Collection c2 = new ArrayList();
String s =",";
String s7 = "that";
String s8 = "is";
String s9 = "the";
String s10 = "question";
c2.add(s);
c2.add(s7);
c2.add(s8);
c2.add(s9);
c2.add(s10);
//将新的这个集合添加到c这个集合中
c.addAll(c2);
2）删除功能
 void clear():清空所有元素
 boolean remove(Object o):从集合中删除一个元素
 boolean removeAll(Collection c):从集合中删除另一个集合的元素

示例：

//void clear():清空所有元素
c.clear();
//boolean remove(Object o):从集合中删除一个元素
c.remove(s6);
3）判断功能
 boolean contains(Object o):判断集合中是否包含指定的元素
 boolean containsAll(Collection c):判断集合中是否包含另一个集合的元素
 boolean isEmpty():判断集合是否为空。

示例：

//boolean contains(Object o):判断集合中是否包含指定的元素
System.out.println(c.contains(s2));
//boolean containsAll(Collection c):判断集合中是否包含另一个集合的元素
System.out.println(c.containsAll(c2));
//boolean isEmpty():判断集合是否为空。
System.out.println(c.isEmpty());
4）交集功能
 boolean retainAll(Collection c)

示例：

//boolean retainAll(Collection c)，求出交集的元素，并删除集合中没有交集的元素
boolean retainAll = c.retainAll(c2);

注意：即使两个集合并没有相同的元素，还是会返回true，这是由于每个集合的子集包含了空集，求交集最少会有一个空集，但是只有空集的时候打印交集是空的，没有元素。

5）集合转数组
 Object[]toArray():把集合转成数组，然后遍历数组，其实就相当于遍历了集合。

示例：

 //Object[]toArray():把集合转成数组，然后遍历数组，其实就相当于遍历了集合。
Object[] o = c.toArray();
for (int i = 0; i < o.length; i++) {
Object object = o[i];
System.out.println(object);
}

3.2迭代器：

Iterator iterator()
Object next():返回迭代的下一个元素,并移动指向的位置
boolean hasNext():判断是否有元素
异常：NoSuchElementException:没有这样的元素异常。
原因：已经获取到元素的末尾了，再继续获取元素，就报错了。

迭代器遍历集合：
迭代器是依赖于集合而存在的。所以，要想得到迭代器对象，必须先有集合对象。

迭代步骤：
A:通过集合对象获取到迭代器对象
B:通过迭代器对象的hasNext()方法判断是否有元素
C:通过迭代器对象的next()方法获取元素

示例：

//使用迭代器进行遍历
Iterator it = c.iterator();

//while遍历
while(it.hasNext()){
System.out.print(it.next()+" ");
}

3.3List集合

（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)

这里给出一个完整的List示例，创建一个List集合，并且调用它的各个方法，用增强型for循环和迭代器两种方法进行遍历。

代码：

//创建一个List集合
List list = new ArrayList();
//添加对象
list.add("二哈");
list.add("金毛");
list.add("柴犬");
//A:添加功能
//void add(int index,Object obj):在指定的位置添加元素
list.add(2, "狗");
//B:删除功能
//Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
Object remove = list.remove(3);
System.out.println(remove);
System.out.println("=============");
//C:获取功能
//get(int index) 返回列表中指定位置的元素。
Object o1 = list.get(0);
System.out.println(o1);
//D:替换功能
//Object set(int index,Object obj)
Object o2 = list.set(0, "牧羊犬");
System.out.println("=============");
//增强型for循环遍历
for (Object object : list) {
System.out.println(object);
}
System.out.println("=============");
//通过迭代器遍历这个集合
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}

结果：



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

示例：

//定义List集合
List list = new ArrayList();
//定义字符串
String str1 = "123";
String str2 = "456";
String str3 = "789";
//把字符串加到List集合
list.add(str1);
list.add(str2);
list.add(str3);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("========");
//List中元素顺序可以被洗牌Collections.shuffle(list)
Collections.shuffle(list);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("========");
//List中元素顺序可以被倒序Collections.reverse(list)
Collections.reverse(list);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("========");
//排序
Collections.sort(list);
//遍历打印
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}

结果：



3.4ArrayList集合

是List接口的实现类，不做过多叙述，这里给出代码示例：

//创建集合
ArrayList list = new ArrayList();
//给集合加元素
list.add("to be");
list.add("or");
list.add("not to be");
//遍历
for(Object object:list){
System.out.print(object+" ");
}

结果：



3.5LinkedList集合：也是List的一个实现类，这里说几个特有功能

  LinkedList特有功能:
public void addFirst(E e)//往LinkedList集合首部添加元素
public void addLast(E e)//往LinkedList集合尾部添加元素

public E getFirst()//获取LinkedList集合首部元素

  public E getLast()//获取LinkedList集合尾部元素

 

  public E removeFirst()//移除LinkedList集合首部元素

   public E removeLast()//移除LinkedList集合尾部添加元素

示例：

//创建linkedlis集合
LinkedList linkedlist = new LinkedList();
//给集合添加元素
linkedlist.add("to be");
linkedlist.add("or");
linkedlist.add("not to be");
//遍历
for(Object object:linkedlist){
System.out.print(object+" ");
}
System.out.println();
System.out.println("=====");
//public void addFirst(E e) 将指定元素插入此列表的开头
linkedlist.addFirst("First");
//遍历
for(Object object:linkedlist){
System.out.print(object+" ");
}
System.out.println();
System.out.println("=====");
//public void addLast(E e)将指定元素添加到此列表的结尾
linkedlist.addLast("End");
//遍历
for(Object object:linkedlist){
System.out.print(object+" ");
}
System.out.println();
System.out.println("=====");
//public E getFirst()返回此列表的第一个元素
Object first = linkedlist.getFirst();
System.out.println(first);
System.out.println("=====");
//public E getLast()返回此列表的最后一个元素
Object last = linkedlist.getLast();
System.out.println(last);
System.out.println("=====");
//public E removeFirst()移除并返回此列表的第一个元素
Object removeFirst = linkedlist.removeFirst();
System.out.println(removeFirst);
System.out.println("=====");
//public E removeLast()移除并返回此列表的最后一个元素
Object removeLast = linkedlist.removeLast();

System.out.println(removeLast);
System.out.println("=====");
//遍历
for(Object object:linkedlist){
System.out.print(object+" ");
}

结果：



3.6
ArrayList与LinkedList的相同点与不同点，这里涉及到了数据结构的特点。

相同点：有顺序的，元素可以重复

不同点：(1)ArrayList特点:
底层数据结构是数组,查询快,增删慢                                     
线程不安全,效率高

(2)LinkedList特点:
底层数据结构是链表,查询慢,增删快
线程不安全,效率高

4.泛型
(1)是一种把明确数据类型的工作推迟到创建对象或者调用方法的时候才去明确类型的特殊类型
(2)格式：
<数据类型>
默认情况下，是Object类型。
这里数据类型只能是引用类型。

示例：用泛型进行限定的List数组，这里限定是String，集合了添加整型是会在编译时报错

//定义集合，加入泛型
List<String>  list = new ArrayList<String>();
//add
list.add("qw");
list.add("asda");
//list.add(1231);
//迭代器遍历
Iterator<String> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
(3)好处：
A:把运行时期问题提前到了编译时期
B:避免了强制类型转换
C:优化程序设计，解决了黄色警告线问题
(4)在集合中用的多

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

例如：public class Generic <E >{}

B:泛型方法（把泛型定义在方法上）

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

例如：public interface Inter <II>{}
(6)泛型通配符

在这里创建一个Animal父类，子类Dog类，Cat类继承于Animal类，方便进行示例：

public class Animal {}
public class Cat extends Animal{}
public class Dog extends Animal{}
<?> 不确定类型：这里用<?>
进行了限定，都不会报错，因为没有进行具体的指定类型。

例如：
//<?> 不确定类型
Collection<?> c5 = new ArrayList<Animal>();
Collection<?> c6 = new ArrayList<Object>();
Collection<?> c7 = new ArrayList<Dog>();
Collection<?> c8 = new ArrayList<Cat>();
<? extends E> 向上限定，E及其子类：这里用<? extends
Animal>进行限定，Animal类和子类对象的创建都不会报错，但是超类Object会报错。

例如：
//<? extends E> 向上限定，E及其子类

Collection<? extends Animal> c9 = new ArrayList<Animal>();
//Collection<? extends Animal> c10 = new ArrayList<Object>();
Collection<? extends Animal> c11 = new ArrayList<Dog>();
Collection<? extends Animal> c12 = new ArrayList<Cat>();
<? super E> 向下限定，E及及其父类：这里用<?
super Animal>进行限定，Animal类和超类Object不会报错，但是子类Dog类和Cat类的对象创建时都会报错

例如：
//<? super E> 向下限定，E及及其父类

Collection<? super Animal> c13 = new ArrayList<Animal>();

Collection<? super Animal> c14 = new ArrayList<Object>();
//Collection<? super Animal> c15 = new ArrayList<Dog>();
//Collection<? super Animal> c16 = new ArrayList<Cat>();