黑马程序员---java基础---4集合框架

最新推荐文章于 2021-09-10 15:08:44 发布

简a零度

最新推荐文章于 2021-09-10 15:08:44 发布

阅读量606

点赞数

本文链接：https://blog.csdn.net/u012421922/article/details/17788661

版权

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

集合

|--Collection

|--List

|--ArrayList

底层数据结构是数组,查询快,增删慢

线程不安全,效率高

|--Vector

底层数据结构是数组,查询快,增删慢

线程安全,效率低

|--LinkedList

底层数据结构是链表,查询慢,增删快

线程不安全,效率高

|--Set

|--HashSet

底层数据结构是哈希表。

是如何保证元素的唯一性的?

它依赖于两个方法：hashCode()和equals()

顺序：

先判断hashCode()，

相同：继续equals()

返回true,不添加

返回fales,添加到集合

不同：添加到集合

|--LinkedHashSet

有序,唯一

底层数据结构是哈希表和链表。

由链表保证有序，由哈希表保证唯一。

|--TreeSet

底层数据结构是二叉树。

是如何保证元素的唯一性的?

根据返回值是否是0判断是否重复。

并且还要保证元素有序：

根据返回值是正数还是负数。

实现方案：

元素具备比较性：Comparable

集合具备比较性：Comparator

3:ArrayList,LinkedList,HashSet,HashMap数据的存储和遍历

A:List

添加功能：add()

遍历功能：

a:迭代器

b:普通for

c:增强for

注意：

如果仅仅是为了遍历,使用a，c都可以。

如果在遍历的过程中，需要知道元素的位置，使用b。

B:Set

添加功能：add()

遍历功能：

a:迭代器

c:增强for

C:Map

添加功能：put()

遍历功能：

a:丈夫找妻子

b:结婚证找丈夫和妻子

注意：

建议使用a，好理解。

1:Collection

(1)集合的由来?

因为面向对象的语言对事物的描述都是以对象体现，

如果要对多个对象进行存储和遍历操作，

就需要用一个容器存储，而对象数组的弊端是长度固定，

所以，为了符合要求，java就提供了

集合类供我们使用。

(2)集合和数组的区别?

A:集合

长度可以改变

只能存储对象类型

可以存储不同类型的对象

B:数组

长度固定

可以存储对象类型，也可以存储基本类型

只能存储同一种类型的对象

(3)集合继承体系的由来?

由于数据结构不同，就会有多种集合的存在，而这多种集合

本身有共性的内容，

通过不断的向上抽取，最终就形成了集合的继承体系结构。

Collection

|--List

|--ArrayList

|--Vector

|--LinkedList

|--Set

|--HashSet

|--TreeSet

针对一种继承体系，是如何学习和使用的呢?

学习：顶层，因为顶层定义的是共性内容。

使用：底层，因为底层才是具体的实现。

(4)Collection接口的功能：

A:添加功能

add(Object obj)

B:删除功能

remove(Object obj)

C:判断功能

contains(Object obj)

D:迭代器功能

Iterator iterator()

E:长度功能

size()

(5)迭代器：

迭代器就是遍历集合元素的一种方式，它依赖集合而存在。

Iterator

|--hasNext()

|--next()

(6)案例：

Collection存储字符串并遍历:
		package cn.itcast;

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

public class Demo5 {
public static void main(String[] args) {
	//创建对象
	Collection c=new ArrayList();
	//添加元素
	 	c.add("world");
		c.add("java");
		c.add("hello");
		//	System.out.println(c);
		 
	Object[]objs=c.toArray();
	for (int i = 0; i < objs.length; i++) {
		//String s=(String)objs[i];
		System.out.println(objs[i]);
	}
		
}
}



		Collection存储自定义对象并遍历:

public class Demo2 {
   public static void main(String[] args) {
	//创建集合对象
	  Collection c=new ArrayList();
	  
	  //创建元素对象
	  Student s=new Student("ww",24);
	  Student s1=new Student("ww1",42);
	  Student s2=new Student("ww2",43);
	  Student s3=new Student("ww3",47);
	  Student s4=new Student("ww4",49);
	  
	  //添加元素
	  c.add(s);
	  c.add(s1);
	  c.add(s2);
	  c.add(s3);
	  c.add(s4);
	  
	  //集合遍历
	  Iterator it= c.iterator();
	  
	  while(it.hasNext()){
		  //创建接收。
		  Student s6=(Student) it.next();//强制
		  //System.out.println(s6);
		  
		  System.out.println(s6.getName()+"\t"+s6.getAge());
	  }
	 
	  
}
}

2:List

(1)List的特点：

Collection

|--List

元素有序(存储顺序和取出顺序一致),

元素可以重复

|--Set

元素无序,唯一

(2)List的特有功能：

A:添加

add(int index,Object obj)

B:删除

remove(int index)

C:获取

Object get(int index)

D:列表迭代器

ListIterator listIterator()

E:修改

set(int index,Object obj)

(3)List的案例：

普通for循环)

List存储字符串并遍历：

List list = new ArrayList();

			list.add("hello");
			list.add("world");
			list.add("java");

			//迭代器
			Iterator it = list.iterator();
			while(it.hasNext())
			{
				String s = (String) it.next();
				System.out.println(s);
			}

			//普通for循环
			for(int x=0; x<list.size(); x++)
			{
				String s = (String)list.get(x);
				System.out.println(s);
			}

		List存储自定义对象并遍历：
package cn.itcast;

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

public class Demo4 {
public static void main(String[] args) {
	//创建对象
	List list=new ArrayList();
	
	//添加元素
	list.add(new Student("zhangsan",23));
	list.add(new Student("lisi",43));
	list.add(new Student("wangwu",53));
	
	//循环
	for (int i = 0; i <list.size(); i++) {
		Student  bb=(Student) list.get(i);
		
		System.out.println(bb.getName()+"\t"+bb.getAge());
	}

	
	
}
}

(4)ListIterator的特殊用法：

A:可以逆向遍历，但是需要先正向遍历，一般不用。

B:并发修改异常

原因：在迭代器遍历的时候，不要使用集合修改集

合本身。

解决方案：

A:使用迭代器遍历的时候，通过迭代器修改

集合。

B:使用集合遍历，通过集合修改集合。

3:Date和DateFormat

(1)Date日期类

Date -- 毫秒值

getTime()

毫秒值 -- Date

构造方法

setTime()

(2)DateFormat格式化类

String -- Date

Date parse(String s)

被解析的字符串一定要和模式一一对应

Date -- String

String format(Date d)

要想得到什么格式，就必须传递什么格式

格式：

yyyy-MM-dd HH:mm:ss

List集合的子类

(1)List的子类特点：

List

|--ArrayList

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

|--Vector

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

|--LinkedList

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

(2)到底使用谁?

根据需求看。

要安全吗:

要：Vector

不要：ArrayList，LinkedList

查询多：ArrayList

增删多：LinkedList

什么都不知道用ArrayList。

2:List

(1)List的特点：

Collection

|--List

元素有序(存储顺序和取出顺序一致),

元素可以重复

|--Set

元素无序,唯一

(2)List的特有功能：

A:添加

add(int index,Object obj)

B:删除

remove(int index)

C:获取

Object get(int index)

D:列表迭代器

ListIterator listIterator()

E:修改

set(int index,Object obj)

(3)List的案例：

普通for循环)

List存储字符串并遍历：

(3)ArrayList
		案例：
			A:存储字符串并遍历：
				ArrayList<String> array = new ArrayList<String>();

				array.add("hello");
				array.add("world");
				array.add("java);

				//方式1
				Iterator<String> it = array.iterator();
				while(it.hasNext())
				{
					String s = it.next();
					System.out.println(s);
				}

				//方式2
				for(int x=0; x<array.size(); x++)
				{
					String s = array.get(x);
					System.out.println(s);
				}

				//方式3
				for(String s : array)
				{
					System.out.println(s);
				}

			B:存储自定义对象并遍历：
package cn.itcast;

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

public class Demo {
public static void main(String[] args) {
	//创建对象
	ArrayList<Student> array=new ArrayList<Student>();
	//添加元素对象
	
	array.add(new Student("zhangsan",23));
	array.add(new Student("lisi",33));
	array.add(new Student("wangwu",34));
	array.add(new Student("zhaoliu",43));
	array.add(new Student("tianqi",26));
	
	//遍历、
	Iterator<Student> it=array.iterator();
	while(it.hasNext()){
		Student s=it.next();
		System.out.println(s.getAge()+s.getName());
		
		for (int i = 0; i < array.size(); i++) {
			Student s1=array.get(i);
			System.out.println(s1.getName()+"\t"+s1.getAge());
		}
	}
		//for (Student student : array) {
		//System.out.println(student.getAge()+"\t"+student.getName());
	
	
	
	
}
}


package cn.itcast;

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

public class Demo {
public static void main(String[] args) {
	//创建对象
	ArrayList<Student> array=new ArrayList<Student>();
	//添加元素对象
	
	array.add(new Student("zhangsan",23));
	array.add(new Student("lisi",33));
	array.add(new Student("wangwu",34));
	array.add(new Student("zhaoliu",43));
	array.add(new Student("tianqi",26));
	
	//遍历、
	Iterator<Student> it=array.iterator();
	while(it.hasNext()){
		Student s=it.next();
		System.out.println(s.getAge()+s.getName());
		
		for (int i = 0; i < array.size(); i++) {
			Student s1=array.get(i);
			System.out.println(s1.getName()+"\t"+s1.getAge());
		}
	}
		//for (Student student : array) {
		//System.out.println(student.getAge()+"\t"+student.getName());
	
	
	
	
}
}


	(4)Vector
		有特有功能，但是写法复杂，所以不使用。
	(5)LinkedList
		存储字符串并遍历：


package cn.itcast;

import java.util.Iterator;
import java.util.LinkedList;

public class Demo2 {

	
	public static void main(String[] args) {
	//Linkedlist自定义元素并遍历
		
		//创建对象
		LinkedList<String> list=new LinkedList<String>();
		
		//添加元素
		list.add("hello");
		list.add("java");
		list.add("world");
		
		//遍历
		//Iterator<String> it= list.iterator();
		/*while(it.hasNext()){
			String s = it.next();
			System.out.println(s);
		}
		for (int i = 0; i < list.size(); i++) {
			String s1 = it.next();
			System.out.println(s1);
			
		}*/
		
		for (String string : list) {
			System.out.println(string);
			
		}
	}

}


		存储自定义对象并遍历：

package cn.itcast;

import java.util.Iterator;
import java.util.LinkedList;

public class Demo3 {
	public static void main(String[] args) {
		
		//创建对象
		LinkedList<Student> list=new LinkedList<Student>();
		
		
		//添加对象元素
		list.add(new Student("zhangsan",23));
		list.add(new Student("lisi",33));
		list.add(new Student("wangwu",34));
		list.add(new Student("zhaoliu",43));
		list.add(new Student("tianqi",26));
		
		//遍历
		//Iterator<Student> it=list.iterator();
		/*for (int i = 0; i < list.size(); i++) {
			Student s=it.next();
			System.out.println(s.getName()+"\t"+s.getAge());
		}
		while(it.hasNext()){
			Student s=it.next();
			System.out.println(s.getName()+"\t"+s.getAge());
		}*/
		for (Student student : list) {
			
			System.out.println(student.getName()+"\t"+student.getAge());
			
		}
	}

}

6)案例：

A:ArrayList

去掉重复元素。

B:LinkedList

特有功能：可以直接添加，删除，获取第一个或者最后一个。

面试题：模拟栈数据结构。

3:泛型

(1)是一种特殊的类型，它把明确类型的操作推迟到了创建对象或者调用方法的时候。

(2)格式：

<数据类型>

(3)好处：

A:把运行期间的错误提前到了编译期间

B:避免了强制类型转换

C:优化了程序设计，解决了黄色警告线

(4)使用：

一般就是在集合中。

(5)泛型概述

A:泛型类

B:泛型方法

C:泛型接口

4:增强for

(1)是一种遍历数据(数组或者Collection集合)的方式。

(2)格式：

for(数组或者Collection集合的元素的数据类型变量名 : 数组或者Collection集合的名字)

{

变量名(其实就是数组或者集合中的元素)

}

(3)好处：

方便了数组或者Collection集合的遍历。

(4)注意：

如果增强for的目标是一个null,就会有空指针一次。

1:Set

(1)Collection

|--List 元素有序,可重复

|--Set 元素无序,唯一

(2)HashSet存储元素和保证元素的唯一性

A:HashSet的底层数据结构是哈希表，保证元素的唯一性.

B:如何保证的呢?

它底层依赖两个方法：hashCode()和equals()。

顺序：

首先判断hashCode()是否相同：

是：继续equals()方法

返回false:说明集合中没有这个元素，添加

返回true:说明集合中有这个元素，不添加

否：直接添加到集合。

(3)HashSet存储字符串和自定义对象(同一个对象是根据需求)并遍历

A:字符串

		B:自定义对象(姓名和年龄都相同极为同一个人)

			public class Student
			{
				private String name;
				private int age;

				//构造方法和get/set方法省略...

				//自己在写一遍，以后就自动生成。
				public int hashCode()
				{
					return this.name.hashCode()+this.age*13;
				}

				public boolean equals(Object obj)
				{
					if(this==obj)
					{
						return true;
					}

					if(!(obj instanceof Student))
					{
						return false;
					}

					Student s = (Student)obj;
					return this.name.equals(s.name) && this.age == s.age;
				}
			}

(4)TreeSet存储字符串和自定义对象保证元素唯一性和排序

TreeSet的底层数据结构是二叉树。

是怎么保证的呢?

根据返回值是否是0来判断元素是否重复。

根据返回值是正数还是负数来判断元素该如何存储。

有几种方案：

元素具备比较性：

就是实现自然排序接口Comparable

集合具备比较性：

就是实现比较器接口Comparator

(5)TreeSet存储字符串和自定义对象(同姓名同年龄即为同一个人，按照年龄排序)并遍历(理解)

(6)LinkedHashSet:

请问这个集合是什么意思?

元素有序,唯一。

由链表保证元素有序,由哈希表保证元素唯一。

2:集合常见的数据结构：

(1)ArrayXxx 底层数据结构是数组,查询快,增删慢

(2)LinkedXxx 底层数据结构是链表,查询慢,增删快

(3)HashXxx 底层数据结构是哈希表,保证元素唯一依赖两个方法：hashCode()和equals()

(4)TreeXxx 底层数据结构是二叉树,保证元素唯一和排序：自然排序，比较器排序。

3:Arrays

Arrays:

public static <T> List<T> asList(T... a)

注意：如果是把一个数组的元素转出了一个集合，不能对集合进行增删操作，但是可以做修改操作。

String[] strArray = { "hello", "world", "java" };

List<String> list = Arrays.asList(strArray);

list.set(1, "itcast");

for (String str : list) {

System.out.println(str);

}

System.out.println("*****************");

for(String str : strArray){

System.out.println(str);

4:可变参数

可变参数：数据类型 ... 变量

注意：这个变量其实是一个数组。

这些数据类型一致。

如果有可变参数的情况，还有其他的参数，可变参数放最后。

这种情况下，我们都不知道有多少个参数，但是，在实际运行的那一刻是知道的。

所以，在定义功能的时候，我们只能用可变参数表示。

5:静态导入

静态导入：

import static 包名....类名.方法名

导入级别：方法级别。

虽然不错，但是不用。

因为如果本类还有静态的同名方法，那么优先使用本类的方法。

所以，永远还是建议即使是静态方法，也最好限定类名。

1:Map

(1)Map是一个双列的集合，可以看成是一个夫妻对。

(2)特点：

元素都是成对出现的。

键是唯一的。

值可以重复。

理解：键 -- 学号

值 -- 学生姓名

(3)Map和Collection的区别?面试题

A:Map是双列集合,元素是成对出现,键唯一,值可以重复。

B:Collection是单列集合,元素是单独出现,它的子类Set的元素是唯一的。

(4)Map接口功能概述：

A:添加功能

V put(K key,V value):如果键不存在，就添加。如果键存在，就替换。

B:判断功能

boolean containsKey(K key):判断键在集合中是否存在

boolean containsValue(V value):判断值在集合中是否存在

C:删除功能

V remove(K key):根据键删除元素,并返回该键对应的值

D:长度功能

int size():返回集合的元素个数

E:遍历功能

V get(K key):根据键获取值

Set<K> keySet():获取键的集合

Collection<V> values():获取值得集合

Set<Map.Entry<K,V>> entrySet():获取键值对对象的集合

(4)TreeSet存储字符串和自定义对象保证元素唯一性和排序

TreeSet的底层数据结构是二叉树。

是怎么保证的呢?

根据返回值是否是0来判断元素是否重复。

根据返回值是正数还是负数来判断元素该如何存储。

有几种方案：

元素具备比较性：

就是实现自然排序接口Comparable

集合具备比较性：

就是实现比较器接口Comparator

(5)TreeSet存储字符串和自定义对象(同姓名同年龄即为同一个人，按照年龄排序)并遍历(理解)

(6)LinkedHashSet:

请问这个集合是什么意思?

元素有序,唯一。

由链表保证元素有序,由哈希表保证元素唯一。

2:集合常见的数据结构：

(1)ArrayXxx 底层数据结构是数组,查询快,增删慢

(2)LinkedXxx 底层数据结构是链表,查询慢,增删快

(3)HashXxx 底层数据结构是哈希表,保证元素唯一依赖两个方法：hashCode()和equals()

(4)TreeXxx 底层数据结构是二叉树,保证元素唯一和排序：自然排序，比较器排序。

3:Arrays

Arrays:

public static <T> List<T> asList(T... a)

注意：如果是把一个数组的元素转出了一个集合，不能对集合进行增删操作，但是可以做修改操作。

String[] strArray = { "hello", "world", "java" };

List<String> list = Arrays.asList(strArray);

list.set(1, "itcast");

for (String str : list) {

System.out.println(str);

}

System.out.println("*****************");

for(String str : strArray){

System.out.println(str);

4:可变参数

可变参数：数据类型 ... 变量

注意：这个变量其实是一个数组。

这些数据类型一致。

如果有可变参数的情况，还有其他的参数，可变参数放最后。

这种情况下，我们都不知道有多少个参数，但是，在实际运行的那一刻是知道的。

所以，在定义功能的时候，我们只能用可变参数表示。

5:静态导入

静态导入：

import static 包名....类名.方法名

导入级别：方法级别。

虽然不错，但是不用。

因为如果本类还有静态的同名方法，那么优先使用本类的方法。

所以，永远还是建议即使是静态方法，也最好限定类名。

1:Map

(1)Map是一个双列的集合，可以看成是一个夫妻对。

(2)特点：

元素都是成对出现的。

键是唯一的。

值可以重复。

理解：键 -- 学号

值 -- 学生姓名

(3)Map和Collection的区别?面试题

A:Map是双列集合,元素是成对出现,键唯一,值可以重复。

B:Collection是单列集合,元素是单独出现,它的子类Set的元素是唯一的。

(4)Map接口功能概述：

A:添加功能

V put(K key,V value):如果键不存在，就添加。如果键存在，就替换。

B:判断功能

boolean containsKey(K key):判断键在集合中是否存在

boolean containsValue(V value):判断值在集合中是否存在

C:删除功能

V remove(K key):根据键删除元素,并返回该键对应的值

D:长度功能

int size():返回集合的元素个数

E:遍历功能

V get(K key):根据键获取值

Set<K> keySet():获取键的集合

Collection<V> values():获取值得集合

Set<Map.Entry<K,V>> entrySet():获取键值对对象的集合

5)案例：
		A:键和值都是字符串。
			HashMap<String,String> hm = new HashMap<String,String>();

			hm.put("001","hello");
			hm.put("002","world");
			hm.put("003","java");

			//方式1
			Set<String> set = hm.keySet();
			for(String key : set)
			{
				String value = hm.get(key);
				System.out.println(key+"***"+value);
			}

			//方式2
			Set<Map.Entry<String,String>> set2 = hm.entrySet();
			for(Map.Entry<String,String> me : set2)
			{
				String key = me.getKey();
				String value = me.getValue();
				System.out.println(key+"***"+value);
			}

B:键是字符串,值是自定义对象。

C:键是自定义对象,值是字符串。(分别使用HashMap和TreeMap实现)

通过这个例子：Map集合的数据结构，只针对键有效。

(6)HashMap和Hashtable的区别?面试题

A:HashMap 线程不安全,效率高。允许null键和值

B:Hashtable 线程安全,效率低。不允许null键和值

2:Collections

(1)Collections是对集合操作的工具类。

(2)Collection和Collections的区别?(面试题)

A:Collection是单列集合的顶层接口,定义了单列集合的共性方法。

B:Collections是操作集合的工具类,定义了排序和查找等方法。

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ------------

简a零度

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员---java基础---4集合框架

---------------------- ASP.Net+Android+IOS">http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发、.Net">http://edu.csdn.net"target="blank">.Net培训、期待与您交流！ ----------------------集合|--Coll
复制链接

扫一扫