Java基础知识 19
数据结构与算法
数据结构与算法:
数据结构:数据的存储方式。
常见的数据结构:栈 队列 数组 链表 二叉树 哈希表
栈的数据结构特点:先进后出,后进先出。弹夹就是典型的栈结构
队列的特点:先进的先出,后进的后出。
数组的特点:数组的元素都标有索引,查询快,增删慢。
链表的特点:查询慢,增删快。
list接口下的三个子类特点:
Arraylist集合:底层使用的是数组,查询快,增删慢。线程不安全,效率高。
Linkedlist集合:底层使用的是链表,查询慢,增删快。线程不安全,效率高。
Vector:底层使用的是数组,查询快,增删慢。线程安全,效率低。
ArrayList集合
ArrayList:底层使用的是数组,查询快,增删慢。此实现不是同步的,是线程不安全的,效率高。
(1)遍历方式有四种:
(1)Iterator iterator = list.iterator();//用hasNext和next方法
(2)ListIterator listIterator = list.listIterator();//自己特有的迭代器
(3)for循环,size()和get()方法
ArrayList集合新的迭代方法:
(4)JDK1.8之后提供了一种迭代方法。
void forEach(Consumer<? super E> action)
执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.function.Consumer;
public class Mytest {
public static void main(String[] args) {
//List接口的大小可变数组的实现,实现了所有可选列表操作,并允许包括null在内的所有元素。
//ArrayList:底层使用的是数组,查询快,增删慢。注意:此实现不是同步的,是线程不安全的。效率高。
//元素有序的(存取顺序一致) 元素编有索引,允许元素重复。
ArrayList list = new ArrayList();
list.add(100);
list.add(200);
list.add(200);
list.add(200);
list.add(300);
list.add(400);
list.add(null);
//遍历方式有:两种迭代器
Iterator iterator = list.iterator();//用hasNext和next方法
ListIterator listIterator = list.listIterator();//自己特有的迭代器
//for循环,size()和get()方法
for (int i = 0; i < list.size(); i++) {
Object obj = list.get(i);
System.out.println(obj);
}
System.out.println("---------------------");
//JDK1.8之后提供了一种迭代方法。
//void forEach(Consumer<? super E> action)
//执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。
list.forEach(new Consumer() {
@Override
public void accept(Object o) {
//o就是集合中的元素
System.out.println(o);
}
});
}
}
(2)ArrayList集合新的排序方法
void sort (Comparator < ? super E > c)
分类列表使用提供的 Comparator比较元素。
排序 Comparator 比较器
import java.util.ArrayList;
import java.util.Comparator;
public class Mytest3 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(50);
list.add(40);
list.add(30);
list.add(20);
list.add(10);
list.add(1);
/*void sort (Comparator < ? super E > c)
分类列表使用提供的 Comparator比较元素。
排序 Comparator 比较器*/
list.sort(new Comparator() {
@Override
public int compare(Object num1, Object num2) {
/*System.out.println(num1);
System.out.println(num2);*/
Integer a= (Integer) num1;
Integer b= (Integer) num2;
return a-b;
//return 0;
}
});
System.out.println(list);
}
}
(3)ArrayList集合删除某些元素:
boolean removeIf (Predicate < ? super E > filter)
删除满足给定谓词的这个集合的所有元素。
(4)判断集合为空的方法:isEmpty();
import java.util.ArrayList;
import java.util.function.Predicate;
public class Mytest4 {
public static void main(String[] args) {
/* boolean removeIf (Predicate < ? super E > filter)
删除满足给定谓词的这个集合的所有元素。*/
ArrayList list = new ArrayList();
list.add(10);
list.add(30);
list.add(50);
list.add(70);
list.add(90);
list.add(100);
list.removeIf(new Predicate() {
@Override
public boolean test(Object obj) {
Integer num= (Integer) obj;
return num>50;
//return true;返回true,就删除集合中的元素
//return false;返回false,不删除集合中的元素
}
});
System.out.println(list);
System.out.println("------------------------");
/*for (int i = 0; i < list.size(); i++) {
Object obj = list.get(i);
Integer num= (Integer) obj;
if (num>50){
list.remove(num);
}
}
System.out.println(list);*/
list.clear();
//判断集合为空的方法:isEmpty()
boolean empty = list.isEmpty();
System.out.println(empty);
if(list.size()==0){
System.out.println("list集合为空!");
}
}
}
Vector集合
vector集合的一些方法:
(1)添加元素---->vector.add(“ab”);
----->vector.addelement(“cd”);
(2)遍历元素:vector.forEach(new Consumer() {
@Override
public void accept(Object obj) {
System.out.println(obj);
}
});
(3)取第一个元素:vector.firstElement();
取最后一个元素:vector.lastElement();
根据索引截取一个元素:vector.elementAt(2);
import java.util.Vector;
import java.util.function.Consumer;
public class Mytest {
public static void main(String[] args) {
Vector vector = new Vector();
vector.add("ab");
vector.addElement("cd");
vector.add("ef");
vector.add("gh");
vector.forEach(new Consumer() {
@Override
public void accept(Object obj) {
System.out.println(obj);
}
});
System.out.println(vector);
System.out.println("-----------------");
/*E firstElement ()
返回此向量的第一个组件(位于索引 0)处的项)。
E lastElement ()
返回此向量的最后一个组件。*/
Object obj = vector.firstElement();
System.out.println(obj);
Object obj2 = vector.lastElement();
System.out.println(obj2);
//elementAt根据索引截取一个元素
Object obj3 = vector.elementAt(2);
System.out.println(obj3);
}
}
(4)Vector容器有一个自己的迭代器,可以遍历集合中的元素。
Enumeration elements(),返回此向量的组件的枚举。
Enumeration 迭代器 hasMoreElements()----->判断还有没有下一个元素
nextElement()----->获取下一个元素
import java.util.Enumeration;
import java.util.Vector;
public class Mytest2 {
public static void main(String[] args) {
Vector vector = new Vector();
vector.addElement(100);
vector.addElement(200);
vector.addElement(300);
vector.addElement(400);
vector.addElement(500);
//Vector 集合中自己的一个迭代器,可以遍历集合中的元素
/* Enumeration<E> elements ()
返回此向量的组件的枚举。*/
/*Enumeration 迭代器
hasMoreElements() 判断还有没有下个元素
nextElement() 获取下一个元素*/
Enumeration elements = vector.elements();
while (elements.hasMoreElements()) {
Object obj = elements.nextElement();
System.out.println(obj);
}
}
}
LinkedList集合
LinkedList:底层数据结构是链表,查询慢,增删快,此实现不是同步的。线程不安全,效率高。
LinkedList集合中的方法:
(1)addFirst():在首位置上增加元素
(2)addLast():在末位置上增加元素
(3)getFirst():返回此列表的第一个元素
(4)getLast():返回此列表的最后一个元素
(5)removeFirst():移除并返回此列表的第一个元素
(6)removeLast():移除并返回此列表的最后一个元素
import java.util.LinkedList;
public class Mytest {
public static void main(String[] args) {
//LinkedList:底层数据结构是链表,查询慢,增删快,注意,此实现不是同步的。线程不安全,效率高
LinkedList linkedList = new LinkedList();
linkedList.add(200);
//在首位置上增加元素
linkedList.addFirst(100);
linkedList.addFirst(50);
linkedList.addFirst(20);
//在末位置上增加元素
linkedList.addLast(300);
linkedList.addLast(400);
linkedList.addLast(500);
System.out.println(linkedList);
System.out.println("-------------------------");
/*E getFirst ()
返回此列表的第一个元素*/
Object first = linkedList.getFirst();
System.out.println(first);
/*E getLast ()
返回此列表的最后一个元素。*/
Object last = linkedList.getLast();
System.out.println(last);
System.out.println("-------------------------");
/*E removeFirst ()
移除并返回此列表的第一个元素。*/
Object o = linkedList.removeFirst();
System.out.println(o);
System.out.println(linkedList);
/*E removeLast ()
移除并返回此列表的最后一个元素。*/
Object o1 = linkedList.removeLast();
System.out.println(o1);
System.out.println(linkedList);
}
}
(7)poll():获取并移除此列表的头(第一个元素)
(8)pollFirst():获取并移除此列表的第一个元素,如果此列表为空,则返回null
(9)pollLast():获取并移除此列表的最后一个元素,如果此列表为空,则返回null
import java.util.LinkedList;
public class Mytest2 {
public static void main(String[] args) {
/*E poll ()
获取并移除此列表的头(第一个元素)
E pollFirst ()
获取并移除此列表的第一个元素;如果此列表为空,则返回 null。
E pollLast ()
获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。*/
LinkedList linkedList = new LinkedList();
linkedList.add(100);
linkedList.add(200);
linkedList.add(300);
linkedList.add(400);
linkedList.add(500);
linkedList.add(600);
Object poll = linkedList.poll();
System.out.println(poll);
System.out.println(linkedList);
System.out.println("-----------------------");
Object poll2 = linkedList.poll();
System.out.println(poll2);
System.out.println(linkedList);
System.out.println("-----------------------");
Object poll3 = linkedList.poll();
System.out.println(poll3);
System.out.println(linkedList);
System.out.println("-----------------------");
Object poll4 = linkedList.poll();
System.out.println(poll4);
System.out.println(linkedList);
System.out.println("-----------------------");
Object o = linkedList.pollFirst();
System.out.println(o);
System.out.println(linkedList);
System.out.println("-----------------------");
Object o1 = linkedList.pollLast();
System.out.println(o1);
System.out.println(linkedList);
}
}
(10)pop():从此列表所表示的堆栈处弹出第一个元素
(11)push():将元素推入此列表所表示的堆栈
import java.util.LinkedList;
public class Mytest3 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(100);
linkedList.add(200);
linkedList.add(300);
linkedList.add(400);
linkedList.add(500);
linkedList.add(600);
//pop(),从此列表所表示的堆栈处弹出第一个元素
Object pop = linkedList.pop();
System.out.println(pop);
System.out.println(linkedList);
System.out.println("-------------------");
pop = linkedList.pop();
System.out.println(pop);
System.out.println(linkedList);
System.out.println("-------------------");
//push(),将元素推入此列表所表示的堆栈
linkedList.push(700);
linkedList.push(800);
System.out.println(linkedList);
}
}
LinkedList集合框架练习题
public class Mytest2 {
public static void main(String[] args) {
/*A:
案例演示:
需求:请用LinkedList模拟栈数据结构的集合,并测试
先进的后出,后进的先出*/
MyList myList = new MyList();
myList.addEle(100);
myList.addEle(200);
myList.addEle(300);
myList.addEle(400);
myList.addEle(500);
Object ele = myList.getEle();
System.out.println(ele);
System.out.println("------------------");
ele = myList.getEle();
System.out.println(ele);
System.out.println("------------------");
ele = myList.getEle();
System.out.println(ele);
System.out.println("------------------");
ele = myList.getEle();
System.out.println(ele);
System.out.println("------------------");
ele = myList.getEle();
System.out.println(ele);
System.out.println("------------------");
}
}
----------------------------------------
import java.util.LinkedList;
public class MyList {
private final LinkedList linkedList;
public MyList(){
//创建linkedList
linkedList = new LinkedList();
}
//1.添加元素的方法
public void addEle(Object obj) {
//调用linkedlist里面的方法,来添加元素。
linkedList.addFirst(obj);
}
//2.取出元素的方法
public Object getEle() {
//把元素取出来
Object pop = linkedList.pop();
//再把元素加回去
linkedList.addLast(pop);
return pop;
}
}
ArrayList集合框架练习题
import java.util.ArrayList;
public class Mytest2 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Student("小红",23));
list.add(new Student("小绿",24));
list.add(new Student("小蓝",25));
list.add(new Student("小紫",26));
list.add(new Student("小清",27));
list.add(new Student("小红",23));
list.add(new Student("小绿",24));
list.add(new Student("小蓝",25));
list.add(new Student("小紫",26));
list.add(new Student("小清",27));
for (int i = 0; i < list.size(); i++) {
Object obj = list.get(i);
Student student= (Student) obj;
System.out.println(student);
}
System.out.println("------------------------");
//去除重复元素
ArrayList newList = new ArrayList();
for (int i = 0; i < list.size(); i++) {
Object obj = list.get(i);
Student student= (Student) obj;
//这里的contains内部采用的是equals方法,因此我们必须重写equals方法
if(!newList.contains(student)){
newList.add(student);
}
}
for (int i = 0; i < newList.size(); i++) {
Object obj = newList.get(i);
Student student= (Student) obj;
System.out.println(student);
}
}
}
---------------------------------------
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
练习题:
去除集合中的重复元素:要求两种方法:(1)不能创建新的容器,就在本容器中做
(2)创建一个新的容器
public class Mytest {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(200);
list.add(2);
list.add(20);
list.add(20);
list.add(300);
list.add(350);
list.add(200);
list.add(2);
list.add(20);
list.add(20);
list.add(300);
list.add(350);
list.add(200);
list.add(2);
list.add(20);
list.add(20);
list.add(300);
list.add(350);
//去除集合中的重复元素,要求,不能重建新的容器来做,就在本容器中操作
//采用选择排序法的思想:用第一个元素和后面的元素进行对比。
for (int i = 0; i < list.size()-1; i++) {
for (int j = i+1; j < list.size(); j++) {
if(list.get(i).equals(list.get(j))){
list.remove(j);
//原来的1位置上的元素去除以后,下一个位置上就变成了1位置。
//但是咱们这时候有一个j++,j就从1变成了2.把此时的1位置就跳过了。直接到了2位置。
//就是这个j必须得和i是连着的。不能是中间跨了一个数。跨了一个数就把一个元素丢了
j--;//j必须--
}
}
}
}
}
import java.util.ArrayList;
public class Mytest {
public static void main(String[] args) {
/* A:
案例演示
需求:ArrayList去除集合中字符串的重复值(字符串的内容相同)
思路:创建新集合方式*/
ArrayList list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");
System.out.println(list);
//思路:创建一个新集合
ArrayList newList = new ArrayList();
//遍历旧集合
for (int i = 0; i < list.size(); i++) {
Object obj = list.get(i);
//将旧集合中的元素取出来,放到新集合中,如果新集合中不包含这个元素,再往集合中加。
if (!newList.contains(obj)){
newList.add(obj);
}
}
System.out.println(newList);
}
}