目录
一：集合
1.什么是集合
定义：通俗的说，集合就是一个放数据的容器，准确的说是放数据对象引用的容器。
集合可以分为两大体系，一个是Collection，一个是 Map。Coection接口又分别被List和Set继承，List被AbstractList实现，然后分为3个子类，ArrayList，LinkList和Vector。Set被AbstractSet实现，又分为HashSet和TreeSet。而Map衍生出的集合分为HashMap,HashTable和TreeMap。
Coection接口：
1.定义的是所有单列集合中共性的方法。
2.所有的单列集合都可以使用共性的方法。
3.没有索引的方法。
Map接口：
1.双列数据，保存具有映射关系“key-value对”的集合。
常用功能：
java.util.Collection接口
所有单列结合顶层的接口，里面定义了所有单列集合共性的方法。 任意的单列集合都可以使用Collection接口的方法。
共性的方法：
public boolean add(E e);把给定的对象添加到当前集合中
public void clear();清空集合中的所有元素
public boolean remove(E e);把给定的对象在当前集合中删除
public boolean contains(E e);判断当前的集合中是否包含给定的对象
public boolean isEmpty(E e);判断当前集合是否为空
public int size();返回元素中集合的个数
public Object[] toArray();把集合中的当前元素，存储到数组中
package Demo01;
import java.util.ArrayList;
import java.util.Collection;
/*
@Author 代码贩子、 --南京邮电大学
*/
/*
java.util.Collection接口
所有单列结合顶层的接口，里面定义了所有单列集合共性的方法。
任意的单列集合都可以使用Collection接口的方法。
共性的方法：
public boolean add(E e);把给定的对象添加到当前集合中
public void clear();清空集合中的所有元素
public boolean remove(E e);把给定的对象在当前集合中删除
public boolean contains(E e);判断当前的集合中是否包含给定的对象
public boolean isEmpty(E e);判断当前集合是否为空
public int size();返回元素中集合的个数
public Object[] toArray();把集合中的当前元素，存储到数组中
*/
public class jihe {
public static void main(String[] args) {
//创建集合对象，可以使用多态
Collection<String> collection = new ArrayList<>();
System.out.println(collection);//重写了toString方法，打印的是空字符串
//public boolean add(E e);把给定的对象添加到当前集合中
//返回值是一个布尔值，一般都返回true，所以可以不用接收
boolean b1 = collection.add("张三");
System.out.println(b1);//以后不用接收这个返回值，因为没有意义
collection.add("李四");
collection.add("王五");
System.out.println(collection);
//public boolean remove(E e);把给定的对象在当前集合中删除
//返回值是一个布尔值，集合中存在元素，删除元素，返回true
//集合中不存在元素，删除失败，返回false
boolean b2 = collection.remove("田七");
collection.remove("李四");
System.out.println(b2);
System.out.println(collection);
//public boolean contains(E e);判断当前的集合中是否包含给定的对象
//返回值是一个布尔值，集合中存在元素，包含元素，返回true
//集合中不存在元素，不包含元素，返回false
boolean b3 = collection.contains("田七");
collection.contains("张三");
System.out.println(b3);
System.out.println(collection);
//public boolean isEmpty(E e);判断当前集合是否为空
//返回值是一个布尔值，集合为空，返回true
//集合不为空，返回false
boolean b4 = collection.isEmpty();
System.out.println(b4);
System.out.println(collection);
//public int size();返回元素中集合的个数
int size = collection.size();
System.out.println(size);
//public Object[] toArray();把集合中的当前元素，存储到数组中
Object[] arr = collection.toArray();//Object可以存储任意的元素，可以把集合编程一个数组
for (int i = 0; i <arr.length ; i++) {
System.out.println(arr[i]);
}
//public void clear();清空集合中的所有元素
collection.clear();
System.out.println(collection);
System.out.println(collection.isEmpty());
}
}
2.List的特点
1.有序的集合（存储和取出元素的顺序相同）。
2.允许存储重复的元素。
3.有索引，可以使用普通的for循环来遍历
3.ArrayList和LinkedList的区别
二者都线程不安全。ArrayList实现了基于动态数组的数据结构，LinkList是基于链表的数据结构。对于随机访问的set和get的方法，ArrayList要比LinkList更加优秀，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。
4.set的提点
无序，不重复。
5.map的特点
无序、以键值对的形式添加元素，键不能重复，值可以重复。它没有继承Collection接口。
6.ArrayList
7.泛型
泛型是一种未知的数据类型，当我们不知道数据类型是什么的时候，可以使用泛型。
泛型可以看作是一个变量，用来接收数据类型。
7.1.不带泛型
好处：可以存储任何的数据类型。
坏处：在需要使用存储类型的时候需要向下转型，如果没有instanceof就容易报错ClassCastException。
7.2带泛型（公司用）
好处：1.将运行期可能出现的问题提前到编译期，如果ArrayList的泛型是String就只能存储String类型。存储别的类型就会报错。
2.可以使用泛型中数据特有的方法。
坏处：只能存储一种数据类型。
8.LinkedList实战
package Demo02;
public class New {
private Integer id;
private String name;
private String title;
public New() {
}
public New(Integer id, String name, String title) {
this.id = id;
this.name = name;
this.title = title;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}
package Demo02;
import java.util.LinkedList;
public class psvm {
/*
LinkedList添加数据的方法
*/
public static void main(String[] args) {
New New1 = new New(1,"张三","老板");
New New2 = new New(2,"李四","老板");
New New3 = new New(3,"王五","老板");
New New4 = new New(4,"赵六","老板");
New New5 = new New(5,"田七","老板");
LinkedList<New> linkedList = new LinkedList<New>();
linkedList.add(New1);
linkedList.add(New2);
linkedList.add(New3);
linkedList.add(New4);
linkedList.add(New5);
System.out.println(linkedList.size());
/*
LinkedList删除数据的方法
*/
//精准定位角标来进行删除
linkedList.remove(2);
//删除第一条数据
linkedList.removeFirst();
//删除最后一条数据
linkedList.removeLast();
System.out.println(linkedList.size());
/*
LinkedList查询数据的方法
*/
//查询第一条数据
linkedList.getFirst().getName();
//查询最后一条数据
linkedList.getLast().getName();
//for循环遍历数据
// for (int i = 0; i <linkedList.size() ; i++) {
// System.out.println(linkedList.get(i).getName());
// }
//增强for遍历数据
for (New news: linkedList){
System.out.println("Id"+news.getId()+"name"+news.getName()+"title"+news.getTitle());
}
}
}
9.HashMap实战
特点：键值存储。
package Demo02;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class psvm {
/*
LinkedList添加数据的方法
*/
public static void main(String[] args) {
//1.实例化HashMap容器
HashMap<String,Object> hashMap= new HashMap<String,Object>();
//2.给HashMap容器添加键值对（添加数据）
hashMap.put("a","aaa");
hashMap.put("1","bbb");
hashMap.put("2","ccc");
//3使用增强for来遍历HashMap
//3.1keySet（）代表获取HashMap容器中的所有键的集合
Set<String> sets= hashMap.keySet();
System.out.println(sets);
//3.2增强for循环遍历sets集合将键和值循环遍历出来而得到真正的键
/*
把HashMap键里面的集合全部的提取出来，通过遍历k就可以得到我们对应的值
*/
// for (String s:sets){
// System.out.println(s);
// }
//4.使用迭代器循环遍历HashMap获取键和值
//4.1调用sets的iterator()得到Iterator迭代器
Iterator<String> iterator = sets.iterator();
//4.2通过hasNext()循环判断HashMap容器中是否有下一个值
while (iterator.hasNext()){
//4.3如果有则调用迭代器next()获取对应的值，这个值就是key键
String key = iterator.next();
//4.4得到键之后，调用HashMap容器的get（）方法获取对应的key键的value值
System.out.println("key："+key+";"+"value:"+hashMap.get(key));
}
}
}
9.HashSet实战
特点：唯一，无序。
package Demo03;
import java.util.HashSet;
import java.util.Iterator;
public class Demo03 {
public static void main(String[] args) {
//1.实例化HashSet容器
HashSet<String> sets = new HashSet<String>();
//2.给HashSet容器添加键值对（添加数据）
sets.add("aaa");
sets.add("bbb");
sets.add("ccc");
//3.1keySet（）代表获取HashSet容器中的所有键的集合
Iterator<String> its = sets.iterator();
//4.使用迭代器循环遍历HashSet获取键
//4.1调用sets的iterator()得到Iterator迭代器
while (its.hasNext()){
//4.2如果有则调用迭代器next()获取对应的值，这个值就是key键
String key = its.next();
//4.3得到键之后，调用HashSet容器的get（）方法获取对应的key键
System.out.println("key"+key);
}
}
}
小练习1：遍历List<Map<String,Object>>
package Demo04;
import java.util.*;
public class Demo04 {
public static void main(String[] args) {
//1.准备泛型里的数据
HashMap<String,Object> map = new HashMap<String,Object>();
map.put("a","1");
map.put("b","2");
map.put("c","3");
//2.创建容器ArrayList<Map<String,Object>>
ArrayList<Map<String,Object>> list= new ArrayList<Map<String,Object>>();
//3.准备数据塞入容器中
list.add(map);
//4.遍历ArrayList（从外往里遍历）
for (Map<String,Object> mm :list){
//System.out.println(mm);
//5.获取mm的HashMap容器中的键集合
Set<String> sets = mm.keySet();
//6.获取迭代器
Iterator<String> its = sets.iterator();
//7.循环遍历输出
while (its.hasNext()){
String key = its.next();
System.out.println("key："+key+";"+"value:"+mm.get(key));
}
}
}
}
小练习2：遍历Map<String, Map<String, Object>>
package Demo05;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo05 {
public static void main(String[] args) {
/*
new后面的Map<String,Object>是一个类型
放在外面一定是实现类
数据应该是Map<String,Object>
*/
//1.准备数据
Map<String,Object> m1 = new HashMap<String,Object>();
m1.put("a","1");
m1.put("b","2");
m1.put("c","3");
Map<String,Object> m2 = new HashMap<String,Object>();
m2.put("aa","11");
m2.put("bb","22");
m2.put("cc","33");
Map<String,Object> m3 = new HashMap<String,Object>();
m3.put("aaa","111");
m3.put("bbb","222");
m3.put("ccc","333");
//2.实例化Map<String, Map<String, Object>>()容器
Map<String, Map<String, Object>> map = new HashMap<String, Map<String, Object>>();
//3.给容器塞值
map.put("aaaa",m1);
map.put("bbbb",m2);
map.put("cccc",m2);
//4.获取外层的Map容器
//4.1获取外层Map容器的key键集合
Set<String> sets = map.keySet();
//4.2获取外层Map容器的游标卡尺
Iterator<String> its = sets.iterator();
//4.3通过游标卡尺循环遍历外层Map
while (its.hasNext()){
//4.4通过游标卡尺获取外层Map的key键集合
String key = its.next();
//4.5 打印输出外层Map的key键集合以及value值
System.out.println("外层key："+key);
//5.遍历内层的Map容器
Map<String, Object> map1= map.get(key);
//5.1获取内层Map容器的key键集合
Set<String> setss = map1.keySet();
//5.2获取内层Map容器的游标卡尺
Iterator<String> itss = setss.iterator();
//5.3通过游标卡尺循环遍历内层Map
while (itss.hasNext()){
//5.4通过游标卡尺获取内层Map的key键集合
String key1 = itss.next();
//5.5打印输出内层Map的key键集合以及value值
System.out.println("内层key："+key1+"内层value："+map1.get(key1));
}
}
}
}
二、 Api
老外写的一些类，类中有许多的方法。
1.枚举
关键字：enum
使用非枚举方式实现对Student类中的SEX属性赋值
package Demo06;
public class Text {
public static void main(String[] args) {
Student student = new Student();
student.setSex("女");
System.out.println(student.getSex());
student.setSex("男女");//这里及有问题了 也不是人妖
/*
想要解决这个问题我们可以将他作为一个常量来进行定义、
但是这样做就不能进行多次赋值
private static final String SEX="男";
*/
System.out.println(student.getSex());
}
}
package Demo06;
public class Student {
private String Sex;
public String getSex(){
return Sex;
}
public void setSex(String sex){
this.Sex = sex;
}
}
采用枚举的方式进行解决
package Demo06;
public enum Gender {
男,女
}
package Demo06;
public class Student {
private Gender Sex;
public Gender getSex() {
return Sex;
}
public void setSex(Gender sex) {
Sex = sex;
}
}
package Demo06;
public class Text {
public static void main(String[] args) {
Student student = new Student();
student.setSex(Gender.女);
System.out.println(student.getSex());
student.setSex(Gender.男);
System.out.println(student.getSex());
student.setSex("FALSE");//这里就报错了
}
}
2.包装类
定义：所有的包装类在java.lang包中都有一个相应的包装类。
作用：包装类提供一系列的实用方法，集合不允许存放基本的数据类型，要进行数字的存放时，要使用包装类型。（比如 ArrayList<> arrayList= new ArryList<>;<>l里面要么放Steing类型，要么放包装类型，想要放基本类型就要继续宁包装）.
2.1基本数据类型转换为包装类进行算数运算
package Demo07;
public class demo07 {
public static void main(String[] args) {
int a = 1;
Integer a_new = new Integer(a);
System.out.println(a_new);
byte b = 2;
Byte b_new = new Byte(b);
System.out.println(b_new);
short c = 3;
short c_new = c;
System.out.println(c_new);
}
}
package Demo07;
public class demo07 {
/*
Author:代码贩子、 南京邮电大学
*/
/*
除了Character以外，其余的包装类可将一个字符串作为参数构造的实例
Au
*/
/*
Bollean中除了“ture”（不区分大小写）之外的其它字符串，结果都是False
*/
public static void main(String[] args) {
//场景一：两个字符串进行“+”操作
String a = "123";
System.out.println(a+"1");
//场景二：一个字符串和一个基本数据类型进行“+”操作
String b = "2";
System.out.println(a+1);
//场景三：将基本数据类型转化为字符串
int c = 123;
String d = a+"1";
//场景四：两个数值类型进行“+”操作就会变成岁数操作
System.out.println(123+1);
//场景五：将字符串进行算数操作 需要使用包装类
String f = "123";
Integer f_new = new Integer(f);
System.out.println(f_new+123);
//场景六：字符与基本数据类型进行“+”操作
//Character e = new Character("男")；
Boolean g = new Boolean("dasdasd");
System.out.println(g);
}
}
2.2将包装类转化为数据类型
intValue（）
package Demo07;
public class demo07 {
/*
Author:代码贩子、 南京邮电大学
*/
public static void main(String[] args) {
Integer a = new Integer(123);
int a_new = a.intValue();
Double b = new Double(3.1415926);
b.doubleValue();
Boolean c = new Boolean(true);
c.booleanValue();
}
}
toString（）基本类型转化为字符串类型
package Demo07;
public class demo07 {
/*
Author:代码贩子、 南京邮电大学
*/
public static void main(String[] args) {
//第一种写法
int a = 123;
String b = Integer.toString(a);
double c = 30.0;
String d = Double.toString(c);
//第二种写法（企业常用）
int e = 123;
String f = e+"";
}
}
parseXXX（）字符串类型转换为基本数据类型（Character类型除外）
package Demo07;
public class demo07 {
/*
Author:代码贩子、 南京邮电大学
*/
public static void main(String[] args) {
int rum = Integer.parseInt("36");
System.out.println(rum);
boolean bool1 = Boolean.parseBoolean("false");
System.out.println(bool1);
}
}
valueOf（）
package Demo07;
public class demo07 {
/*
Author:代码贩子、 南京邮电大学
*/
public static void main(String[] args) {
//场景一：基本类型转化为包装类
Integer intvalue= Integer.valueOf(21);
System.out.println(intvalue);
//场景二：字符串类型转化为包装类（Character除外）
Integer inteValue = Integer.valueOf("21");
double doublecalue= Double.valueOf("32");
System.out.println(doublecalue);
//报错场景
String gender = '男';
//编译报错
Character gg = Character.valueOf(gender);
}
}
2.3 装箱和拆箱
定义：（装箱）基本类型转换为包装类型（自动转换！）
（拆箱）包装类对象转换为基本类型的值（自动转换！）
附注：包装类不可以取代基本数据，只有在基本数据类型需要用对象表示的时候使用。
package Demo07;
public class demo07 {
/*
Author:代码贩子、 南京邮电大学
*/
public static void main(String[] args) {
//基本数据类型可以转换为包装类型(装箱) JDK1.5之后自动转化
Integer a = 5;
//包装类型也可以转换为基本数据类型（拆箱）
int b = a;
}
}
2.4 String
package Demo07;
public class demo07 {
/*
Author:代码贩子、 南京邮电大学
*/
public static void main(String[] args) {
//存在在常量池中
String a = "写代码";
//存放在堆中,由变量指向堆中的代码
String string = new String("写代码");
}
}