前言
本期任务:毕向东老师Java视频教程学习笔记(共计25天)
- 原视频链接:黑马程序员_毕向东_Java基础视频教程
- day01:编写HelloWorld程序
- day02:操作符与条件选择语句
- day03:循环语句与函数
- day04:数组
- day07:继承、抽象类与接口
- day08:多态
- day09:异常处理
- day11:多线程
- day12:线程安全与同步机制
- day13:String类
- day14:集合(ArrayList,LinkedList,HashSet)
- day15:集合(TreeSet)和泛型)
- day16:集合(HashMap、TreeMap)
- day17:集合框架的工具类(Arrays、Collections)
- day18:IO流(字符流读写)
- day19:IO流(字节流、转换流读写)
- day20:IO流(File对象)
代码
/*
Collection定义了集合框架的共性功能。
1,添加
add(e);
addAll(collection);
2,删除
remove(e);
removeAll(collection);
clear();
3,判断。
contains(e);
isEmpty();
4,获取
iterator();
size();
5,获取交集。
retainAll();
6,集合变数组。
toArray();
1,add方法的参数类型是Object。以便于接收任意类型对象。
2,集合中存储的都是对象的引用(地址)
什么是迭代器呢?
其实就是集合的取出元素的方式。
如同抓娃娃游戏机中的夹子。
迭代器是取出方式,会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。
*/
import java.util.*;
public class CollectionDemo {
public static void main(String[] args) {
// method_get();
method_get1();
}
public static void method_get(){
ArrayList a1 = new ArrayList();
// 1.添加元素
a1.add("java1");
a1.add("java2");
a1.add("java3");
a1.add("java4");
// 获取迭代器,用于取出集合中的元素
Iterator it = a1.iterator();
// 写法1
while (it.hasNext()){
System.out.println(it.next());
}
//写法2
for (; it.hasNext();)
{
System.out.println(it.next());
}
}
public static void method_get1(){
ArrayList a1 = new ArrayList();
// 1.添加元素
a1.add("java2");
a1.add("java2");
a1.add("java3");
a1.add("java4");
// 打印原集合
System.out.println(a1);
// 删除元素
a1.remove("java2");
System.out.println(a1);
// a1.clear();
// System.out.println(a1);
// 判断元素
System.out.println("java3是否存在:"+a1.contains("java3"));
System.out.println("集合是否为空:"+a1.isEmpty());
// 获取元素个数
System.out.println("size:"+ a1.size());
ArrayList a2 = new ArrayList();
a2.add("java5");
a2.add("java6");
a2.add("java7");
a2.add("java2");
// 取交集,a1中只会保留与a12中不同的元素
a1.retainAll(a2);
System.out.println(a1);
// 去交集,a1中只会保留与a12中不同的元素
a1.removeAll(a2);
System.out.println(a1);
}
}
import java.util.*;
/*
去除ArrayList集合中的重复元素。
*/
public class ArrayListTest {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("java1");
al.add("java1");
al.add("java2");
al.add("java3");
System.out.println(al);
System.out.println(singleElements(al));
}
public static ArrayList singleElements(ArrayList al) {
// 定义一个临时容器
ArrayList newAl = new ArrayList();
for (Iterator it = al.iterator(); it.hasNext(); ) {
Object obj = it.next();
if (newAl.contains(obj)) {
continue;
} else {
newAl.add(obj);
}
}
return newAl;
}
}
import java.util.*;
/*
将自定义对象作为元素存到ArrayList集合中,并去除重复元素。
比如:存人对象。同姓名同年龄,视为同一个人。为重复元素。
思路:
1,对人描述,将数据封装进人对象。
2,定义容器,将人存入。
3,取出。
List集合判断元素是否相同,依据是元素的equals方法。
*/
class Person {
private int age;
private String name;
Person(int age, String name) {
this.age = age;
this.name = name;
}
// 自定义的类,需要重写equals函数,使得对象可比较
public boolean equals(Object obj) {
if (!(obj instanceof Person)) {
return false;
}
Person p = (Person) obj; // obj当前为object类型,所以需要强制类型转换
return p.age == this.age && p.name.equals(this.name);
}
}
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add(new Person(10, "张三"));
al.add(new Person(10, "张三"));
al.add(new Person(11, "李四"));
al.add(new Person(12, "王五"));
System.out.println(al);
System.out.println(singleElements(al));
}
public static ArrayList singleElements(ArrayList al) {
// 定义一个临时容器
ArrayList newAl = new ArrayList();
for (Iterator it = al.iterator(); it.hasNext(); ) {
Object obj = it.next();
if (newAl.contains(obj)) {
continue;
} else {
newAl.add(obj);
}
}
return newAl;
}
}
/*
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈:先进后出 如同一个杯子。
队列:先进先出 First in First out FIFO 如同一个水管。
*/
import java.util.*;
// 模拟实现栈
class Stack {
private LinkedList ll;
Stack() {
ll = new LinkedList();
}
public void myAdd(Object obj) {
ll.addLast(obj);
}
public Object myGet() {
return ll.pollLast();
}
public boolean isNull() {
return ll.isEmpty();
}
}
// 模拟实现队列
class Queue {
private LinkedList ll;
Queue() {
ll = new LinkedList();
}
public void myAdd(Object obj) {
ll.addLast(obj);
}
public Object myGet() {
return ll.pollFirst();
}
public boolean isNull() {
return ll.isEmpty();
}
}
public class LinkedListTest {
public static void main(String[] args) {
// Queue q = new Queue();
// q.myAdd("张三");
// q.myAdd("张三");
// q.myAdd("李四");
// q.myAdd("王五");
//
// while (!(q.isNull())){
// System.out.println(q.myGet());
// }
Stack s = new Stack();
s.myAdd("张三");
s.myAdd("张三");
s.myAdd("李四");
s.myAdd("王五");
while (!(s.isNull())){
System.out.println(s.myGet());
}
}
}
import java.util.*;
/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。
*/
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.add("java1");
v.add("java2");
v.add("java3");
v.add("java3");
Enumeration en = v.elements();
while (en.hasMoreElements()) {
System.out.println(en.nextElement());
}
}
}
import java.util.*;
/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人,重复元素。
需要重写equals和hashCode
*/
class Person1 {
private int age;
private String name;
Person1(int age, String name) {
this.age = age;
this.name = name;
}
// 自定义的类,需要重写equals和hashCode函数,使得对象可比较
public boolean equals(Object obj) {
if (!(obj instanceof Person1)) {
return false;
}
Person1 p = (Person1) obj; // obj当前为object类型,所以需要强制类型转换
return p.age == this.age && p.name.equals(this.name);
}
public int hashCode() {
return name.hashCode() + age * 47;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
public class HashSetTest {
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add(new Person1(10, "张三"));
hs.add(new Person1(11, "张三"));
hs.add(new Person1(12, "李四"));
hs.add(new Person1(13, "王五"));
System.out.println(hs);
for (Iterator it = hs.iterator(); it.hasNext(); ) {
Person1 p = (Person1) it.next();
System.out.println(p.getName() + "......" + p.getAge());
}
}
}