集合
ArryList与LinkedList
ArryList类常用方法
使用一个类的方法时，一定要去看此类的构造方法（必须的）
boolean add(Object o)
在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)
在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()
返回列表中的元素个数
Object get(int index)
返回指定索引位置处的元素。取出元素是Object类型，使用前需要进行强制类型转换
boolean remove(Object o)
从列表中删除元素
Object remove(int index)
从列表中删除指定位置元素，起始索引位置从0开始
boolean contains(Object o)
判断列表中是否存在指定元素
ArryList各种方法用法例子
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
// 创建3新闻标题类对象
NewsTitle nt1 = new NewsTitle(1001, "合肥新站区和肥西各新增1例新冠肺炎感染者", "合肥日报");
NewsTitle nt2 = new NewsTitle(1002, "合肥今日有暴雨，局部地区特大暴雨", "张三");
NewsTitle nt3 = new NewsTitle(1003, "震惊，程序员每天竟然喜欢干这件事", "李四");
NewsTitle nt4 = new NewsTitle(1004, "安徽泗县昨日新增新冠肺炎无症状感染者23例", "安徽日报");
// 准备集合容器，调用ArrayList类的无参构造方法，创建一个默认长度为10的集合容器
ArrayList al = new ArrayList();
// 将创建的新闻标题对象存储到al集合中
al.add(nt1);
al.add(nt3);
al.add(nt2);
// 获取新闻标题的总数----》获取集合中元素的个数
//int size():返回列表中的元素个数
int size = al.size();
System.out.println("集合中元素的个数：" + size);
// 可以逐条打印每条新闻标题的名称
//Object get(int index):返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
// Object obj1 =al.get(0);
// NewsTitle newsTile1 = (NewsTitle)obj1;
// System.out.println(newsTile1.getName());
//
// Object obj2 =al.get(1);
// NewsTitle newsTile2 = (NewsTitle)obj2;
// System.out.println(newsTile2.getName());
//
// Object obj3 =al.get(2);
// NewsTitle newsTile3 = (NewsTitle)obj3;
// System.out.println(newsTile3.getName());
for (int i = 0; i < al.size(); i++) {
Object obj = al.get(i);
NewsTitle newsTile = (NewsTitle) obj;
System.out.println(newsTile.getId()+"--"+newsTile.getName());
}
//void add(int index,Object o):在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
al.add(0, nt4);
NewsTitle news =(NewsTitle)al.get(0);
System.out.println(news);
//boolean contains(Object o):判断列表中是否存在指定元素，如果集合中存在你要找的元素，返回true，否则返回false
boolean result1 =al.contains(nt3);
System.out.println("集合中存在你要找的元素nt3:"+result1);
//boolean remove(Object o):从列表中删除元素，删除成功返回true，删除失败返回false
boolean result2 =al.remove(nt4);
System.out.println("删除元素成功："+result2);
for (int i = 0; i < al.size(); i++) {
Object obj = al.get(i);
NewsTitle newsTile = (NewsTitle) obj;
System.out.println(newsTile.getId()+"--"+newsTile.getName());
}
System.out.println("---------------");
//Object remove(int index):从列表中删除指定位置元素，起始索引位置从0开始
Object obj =al.remove(0);
NewsTitle newsTile = (NewsTitle) obj;
System.out.println(newsTile);
System.out.println("--------------");
for (int i = 0; i < al.size(); i++) {
Object obje = al.get(i);
NewsTitle newsTilee = (NewsTitle) obje;
System.out.println(newsTilee.getId()+"--"+newsTilee.getName());
}
//clear():清空集合中的所有元素
//al.clear();
//System.out.println(al.size());
//isEmpty():如果此列表中没有元素，则返回 true
//System.out.println(al.isEmpty());
System.out.println("--------------");
//toArray():将集合变成数组
Object[] objs =al.toArray();
for (int i = 0; i < objs.length; i++) {
System.out.println(objs[i]);
}
System.out.println("--------------");
//iterator():迭代器（遍历），将集合中的元素“转移”到了迭代器这么一个容器中，接下来对迭代器容器进行遍历
Iterator it =al.iterator(); //iterator()方法是
//遍历it这个容器，先使用hasNext()方法判断容器中是否有元素，有，使用next()方法取出，然后再判断，如果有，就取出元素，继续再判断，有，继续取出
//it.hasNext():判断迭代器中是否有元素，如果有元素返回true
while(it.hasNext()){
//取出元素
Object object =it.next(); //多态
System.out.println(object);
}
System.out.println("--------------------------------------");
for(Object ob:al){
//子类重写了Object中的toString()方法，上一行代码是向上转型（多态），子类引用指向父类，所以这里的object在println()内部调用的是重写的toString()方法
System.out.println(ob);
}
}
}
LinkedList类常用方法
-
LinkedList类是List接口的一个具体实现类，它是用于创建链表数据结构，当插入或删除元素时，性能会更好
void addFirst(Object o) 在列表的首部添加元素
Object getFirst() 返回列表中的第一个元素
Object getLast() 返回列表中的最后一个元素
Object removeFirst() 删除并返回删除的这个元素
Object removeLast() 删除并返回列表中的最后一个元素
-
例子
public class Test {
public static void main(String[] args) {
// 准备集合中的内容，创建3个NewsTitle类对象
NewsTitle nt1 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三");
NewsTitle nt2 = new NewsTitle(1002, "合肥将变成一个没有传销的城市", "李四");
NewsTitle nt3 = new NewsTitle(1003, "合肥比亚迪即将建成开厂", "王五");
NewsTitle nt4 = new NewsTitle(1004, "大湖名城，创新高低", "赵六");
NewsTitle nt5 = new NewsTitle(1005, "大湖名城，创新高低", "孙七");
//准备容器，创建LinkedList对象
LinkedList list = new LinkedList();
list.add(nt1);
list.add(nt2);
list.add(nt3);
list.addLast(nt5);
list.addFirst(nt4);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-------------获取元素-------------");
System.out.println(list.getFirst());
System.out.println(list.getLast());
System.out.println("-------------删除元素--------------");
System.out.println(list.removeFirst());
System.out.println(list.removeLast());
System.out.println("--------------删除元素后进行遍历-------------");
for (Object object : list) {
System.out.println(object);
}
}
}
输出结果
NewsTitle [id=1004, name=大湖名城，创新高低, author=赵六]
NewsTitle [id=1001, name=Java中还有这么神奇的事情, author=张三]
NewsTitle [id=1002, name=合肥将变成一个没有传销的城市, author=李四]
NewsTitle [id=1003, name=合肥比亚迪即将建成开厂, author=王五]
NewsTitle [id=1005, name=大湖名城，创新高低, author=孙七]
-------------获取元素-------------
NewsTitle [id=1004, name=大湖名城，创新高低, author=赵六]
NewsTitle [id=1005, name=大湖名城，创新高低, author=孙七]
-------------删除元素--------------
NewsTitle [id=1004, name=大湖名城，创新高低, author=赵六]
NewsTitle [id=1005, name=大湖名城，创新高低, author=孙七]
--------------删除元素后进行遍历-------------
NewsTitle [id=1001, name=Java中还有这么神奇的事情, author=张三]
NewsTitle [id=1002, name=合肥将变成一个没有传销的城市, author=李四]
NewsTitle [id=1003, name=合肥比亚迪即将建成开厂, author=王五]
HashSet
HashSet类中的方法
-
boolean add(E e)
int size()
Iterator iterator() 返回此集合中元素的迭代器,元素没有特定的顺序返回。
无get()方法
注：
Iterator接口中的方法
boolean hasNext()
E next()
迭代器作用
是用来访问容器(用来保存元素的数据结构)中的元素,所以使用迭代器,我们就可以访问容器中里面的元素
-
HashSet是Set接口常用的实现类 ，set集合是无序的，所以不能使用get(下标)获取元素
如何遍历Set集合呢？
方法一：
通过获取迭代器Iterator实现遍历
Collection接口的iterator()方法
Iterator接口的方法
boolean hasNext() 判断是否存在另一个可访问的元素
Object next() 返回要访问的下一个元素（因为这不是指向第一个元素，而是先指向的是空元素，所以访问的是下一个元素）
方法二：
增强for循环
-
例子
public class Test {
public static void main(String[] args) {
//准备数据：创建NewsTitle对象
NewsTitle nt1 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三");
NewsTitle nt2 = new NewsTitle(1002, "合肥将变成一个没有传销的城市", "李四");
NewsTitle nt3 = new NewsTitle(1003, "合肥比亚迪即将建成开厂", "王五");
NewsTitle nt4 = new NewsTitle(1004, "大湖名城，创新高低", "赵六");
NewsTitle nt5 = new NewsTitle(1005, "大湖名城，创新高低", "孙七");
//准备容器
HashSet hs = new HashSet();
hs.add(nt1);
hs.add(nt2);
hs.add(nt3);
hs.add(nt4);
hs.add(nt5);
hs.add(nt1);
hs.add(nt1);
System.out.println(hs.size());//5 因为他唯一，当重复了就不再往里加了
for (Object object : hs) { //因为set是无序的，所以每一次遍历都会输出的顺序不同（不考虑内存缓存问题）
System.out.println(object);
}
System.out.println("-------------------");
//set集合是无序的，所以不能使用get(下标)获取元素
//hs.get(0);
Iterator it = hs.iterator();
while(it.hasNext()){
Object obj =it.next();
NewsTitle nt = (NewsTitle)obj;
System.out.println(nt);
}
}
}
-
特例
public class Demo {
public static void main(String[] args) {
Set set = new HashSet();
String s1 = new String("java");
String s2 = s1;
String s3 = new String("JAVA");
NewsTitle nt1 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三");
NewsTitle nt2 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三");
set.add(nt1);
set.add(nt2);
System.out.println(set.size());//2 //new了两个不同的对象，回头搞一下String类和普通类 堆内存和栈内存存放方式
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size());//4
}
}
HashMap
-
例子
public class Test {
public static void main(String[] args) {
//创建学生对象
Student stu1 = new Student("张三", "男"); //已经重写了toString()方法
Student stu2 = new Student("李四", "男");
Student stu3 = new Student("如花", "女");
//创建HashMap集合对象
HashMap hm = new HashMap();
//将学生对象添加到集合中
hm.put("jack", stu1);
hm.put("tom", stu2);
hm.put("rose", stu3);
Object obj = hm.get("jack");
Student stu = (Student)obj;
System.out.println("Jack对应的学员信息为：姓名:"+stu.getName()+"，性别："+stu.getGender());
System.out.println("--------------------------");
//使用键值对的方式遍历输出所有学员的姓名和性别
Set set =hm.entrySet();
for(Object object:set){
Map.Entry me = (Map.Entry)object;
//获取键值对的键
Object obj1 = me.getKey();
String key = (String)obj1;
//获取键值对的值
Object obj2=me.getValue();
Student student = (Student)obj2;
System.out.println(key+"对应的学员姓名："+student.getName()+"，性别为："+student.getGender());
}
}
}
-
使用键值对方式遍历输出
Set set = (new HashMap).entrySet();
for(Object obj : set){
Map.Entry me =(Map.Entry)obj;
Object obj1 =me.getKey(); //获取键值对的健（重写toString()方法，可以直接输出obj1）
Object obj2 =me.getValue(); //获取键值对的值
}
例子
public class Test {
public static void main(String[] args) {
//创建学生对象
Student stu1 = new Student("张三", "男");
Student stu2 = new Student("李四", "男");
Student stu3 = new Student("如花", "女");
//创建HashMap集合对象
HashMap hm = new HashMap();
//将学生对象添加到集合中
hm.put("jack", stu1);
hm.put("tom", stu2);
hm.put("rose", stu3);
Object obj = hm.get("jack");
Student stu = (Student)obj;
System.out.println("Jack对应的学员信息为：姓名:"+stu.getName()+"，性别："+stu.getGender());
System.out.println("--------------------------");
//使用键值对的方式遍历输出所有学员的姓名和性别
Set set =hm.entrySet();
for(Object object:set){
Map.Entry me = (Map.Entry)object;
//获取键值对的键
Object obj1 = me.getKey();
String key = (String)obj1;
//获取键值对的值
Object obj2=me.getValue();
Student student = (Student)obj2;
System.out.println(key+"对应的学员姓名："+student.getName()+"，性别为："+student.getGender());
}
}
}
HashMap常用方法（加上泛型）
-
public V put(K key, V value){}
public V remove(Object key) {}
public int size() {}
public boolean containsKey(Object key) {}
在HashMap集合中，键值对的健若是有，则返回true
public boolean containsValue(Object value) {}
在HashMap集合中，键值对的值若是有，则返回true
public Collection values() {}
返回的是获取值的集合
public Set keySet() {} 返回的是键值对的集合
public Set> entrySet() {} 返回的是将集合中的键值对全部取出来存储到Set集合（我觉得是把引用赋值给Set集合），目的是为了下一步可以调用iterator()方法，因为是在HashMap内部的类实现了iterator方法,HashMap没有办法直接调用这个方法
返回的是获取的是键值对的健的集合(可以直接进行打印，打印出的是健的集合)
这里需要注意一点，那么要分别打印呢？（需要进源码看一下....）
step overF6 不进入内部，只执行自己写的代码
step overF5 进入内部，执行所有需要执行的代码
(HashMap类里面有一个内部类KeySet,而KeySet有继承了AbstractSet)
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable
{
............
private final class KeySet extends AbstractSet {
public Iterator iterator() {
return newKeyIterator();
}
.........
}
}
（Abstract类实现了Set接口，所以重写了Set接口中的iterator()方法，但这个抽象类没有重写iterrator()方法，又被HashMap继承了，所以是HashMap类实现了Set接口中的iterator()方法）
public abstract class AbstractSet extends AbstractCollection implements Set {
}
阿西吧..........
看下面的例子，就是为了看懂下面两行代码
Set keys2 = hm.keySet();
Iterator it = keys2.iterator(); //疑惑就在为什么Set类型的接口可以调用iterator，原因就是HashMap绕了一圈实现了Set接口
例子
public class Test {
public static void main(String[] args) {
//准备键值对容器用来存储键值对
HashMap hm = new HashMap();
//向集合中存储数据
hm.put("CN", "中华人民共和国");
hm.put("RU","俄罗斯联邦");
hm.put("US", "美利坚合众国");
hm.put("JP", "日本");
System.out.println(hm.size());
String str1 =hm.get("CN");
System.out.println(str1);
//Object remove(key):根据键来删除键值对，返回值是键对应的值
String str2=hm.remove("JP");
System.out.println(str2);
System.out.println(hm.size());
System.out.println(hm.containsKey("CN"));//true
System.out.println(hm.containsKey("JP"));//false
System.out.println(hm.containsValue("中华人民共和国"));//true
//keySet():返回集合中所有键值对的键的集合
Set keys=hm.keySet();
for (String object : keys) {
String key = object;
String obj =hm.get(key);
String value = obj;
System.out.println(key+"---"+value);
}
System.out.println("--------------------");
//Collection values():获取值得集合
Collection coll = hm.values();
for (String object : coll) {
String value = object;
System.out.println(value);
}
System.out.println("--------------------");
//获取键的集合
Set keys2 = hm.keySet();
Iterator it = keys2.iterator();
while(it.hasNext()){
String key =it.next();
String value =hm.get(key);
System.out.println(key+"---"+value);
}
System.out.println("--------------------");
//使用键值对的方式取出集合中的键值对
Set> keyValues = hm.entrySet(); //将集合中的键值对全部取出来存储到Set集合
Iterator> iterator =keyValues.iterator();//将Set集合中的元素存储到迭代器中
while(iterator.hasNext()){
Entry me =iterator.next();//使用next()方法获取迭代器中的元素
String key = me.getKey();//键值对类型对象调用getKey()方法可以获取键值对的键
String value=me.getValue();键值对类型对象调用getValue()方法可以获取键值对的值
System.out.println(key+"~~~~~"+value);
}
}
}
泛型
-
将对象的类型作为参数，指定到其它类或者方法上，从而保证类型转换的安全性和稳定性
-
泛型集合可以约束集合内的元素类型
典型泛型集合ArryList、HashMap 对于和表示该泛型集合中的元素类型，泛型集合中的数据不再转换为Object
例子
public class Test {
public static void main(String[] args) {
//创建学生对象
Student stu1 = new Student("张三", "男");
Student stu2 = new Student("李四", "男");
Student stu3 = new Student("如花", "女");
//创建HashMap集合对象
HashMap hm = new HashMap();
//将学生对象添加到集合中
hm.put("jack", stu1);
hm.put("tom", stu2);
hm.put("rose", stu3);
Student stu = hm.get("jack");
System.out.println("Jack对应的学员信息为：姓名:"+stu.getName()+"，性别："+stu.getGender());
System.out.println("--------------------------");
Set> set =hm.entrySet();
//使用迭代器遍历输出所有学员的姓名和性别
Iterator> iterator= set.iterator();
while(iterator.hasNext()){
Entry me = iterator.next();
System.out.println(me.getKey()+"-------"+me.getValue().getName()+"----------"+me.getValue().getGender());
}
System.out.println("---------------------------");
//使用键值对的方式遍历输出所有学员的姓名和性别
for(Map.Entry me:set){
//获取键值对的键
String key = me.getKey();
//获取键值对的值
Student student=me.getValue();
System.out.println(key+"对应的学员姓名："+student.getName()+"，性别为："+student.getGender());
}
}
}
加强for循环
-
public static void main(String[] args) {
//arr
int arr[]={1,2,3,4,5,6};
for(int i : arr){
System.out.println(i);
}
//string
String s [] = {"hello","world","java"};
for(String i : s){
System.out.println(i);
}
//list
List list = new ArrayList();
list.add("hello");
list.add("world");
list.add("java");
for(String i : list){
System.out.println(i);
}
//使用键值对的方式遍历输出所有学员的姓名和性别
HashMap hm = new HashMap();
Student stu1 = new Student("张三", "男");
hm.put("jack", stu1);
Set> set =hm.entrySet();
for(Map.Entry me:set){
//获取键值对的键
String key = me.getKey();
//获取键值对的值
Student student=me.getValue();
System.out.println(key+"对应的学员姓名："+student.getName()+"，性别为："+student.getGender());
}
}
Map.Entry<> 查一下资料，了解一下
这些都是集合或者数组的'引用'进行for循环的
枚举
-
枚举是指由一组固定的常量组成的类型
public enum Genders {
Male,Female
}
（注意下面gender的类型是枚举类型）
public class Student{
private String name;
private Genders gender;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Genders getGender() {
return gender;
}
public void setGender(Genders gender) {
this.gender = gender;
}
}
（注意：stu.setGender(Genders.Male); 该方法里只能传在Gender中已经定义好的）
public class StudentTest {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("张三");
stu.setGender(Genders.Male);
System.out.println(stu.getName()+"--"+stu.getGender());
System.out.println(Math.log10(10));
}
}
Java API
包装类
包装类的作用
提供了一系列使用的方法
集合不允许存放基本数据类型数据，存放数字时，要用包装类型
包装类的构造方法
所有包装类都可将与之对应的基本数据类型作为参数来构造它们的实例
public Type(type value){ //这是8大类型的构造方法，没有无参构造
this.value = value
}
例如
public Integer(int value) {
this.value = value;
}
除Character类外，其它包装可将一个字符串作为参数构造它们的实例
例如
Integer i = new Integer("123");
注意：
Boolean类型构造方法参数为String类型时，若该字符串内容为true（不考虑大小写），则该Boolean对象表示true，否则表示false
Integer i = new Integer("abc")，这个虽然编译不报错，但是运行时会抛出异常，numberformatexception表示数字格式化异常
Byte b = new Byte(1); 与 Short s = new Short((short) 1);必须要进行强制类型转换，因为，你传过去的是int类型的数据，构造函数接收的是小于int类型的数据
包装类型的常用方法
XXXValue():包装类型转换成基本类型
例子
Integer in = new Integer(25);
int i = in.intValue();
