笔记-迎难而上之Java基础进阶1

Collection集合

数组的长度是固定的，集合的长度是可变的

数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。

集合框架

import java.util.Collection;
import java.util.ArrayList;
//Collection的常用方法
public class CollectionDemo{
public static void main(String[] args){
//Collection是一个接口无法创建对象，可以使用多态来使用方法
Collection<String> collection = new ArrayList<>();
//add方法，向集合添加元素
collection.add("李白");
//collection.add(String);不可以添加非指定的类型，
collection.add("苏轼");
collection.add("杜甫");
collection.add("王安石");
collection.add("李清照");
System.out.println(collection);
//remove方法，返回值类型是boolean，把给定的对象删除
//collection.remove("林黛玉");
//System.out.println(aremove);没有则返回false
collection.remove("李清照");
//判断当前集合中是否包含了给定的对象，返回值类型为boolean
boolean acontains = collection.contains("李清照");
System.out.println(acontains);//false
//size,返回集合中元素的个数
int asize = collection.size();
System.out.println(asize);//4
//isEmpty,判断集合是否为空，集合是空，返回true，不是空返回false
boolean aisEmpty = collection.isEmpty();
System.out.println(aisEmpty);//false
//toArray,把集合中的元素，存储到数组中,返回值类型为Object[]数组
Object[] atoArray = collection.toArray();
//遍历数组
for(int i=0;i<atoArray.length;i++){
System.out.println(atoArray[i]);
}
//清空数组clear
collection.clear();
System.out.println(collection);
}}


Iterator接口

Iterator接口有两个常用的方法

boolean hasNext() 如果仍有元素可以迭代，则返回true 用来判断集合中还有没有下一个元素，

E next() 返回迭代的下一个元素

取出集合中的下一个元素

Iterator迭代器，是一个接口，无法直接使用，获取Iterator接口实现类的对象,可以通过Collection接口中的方法iterator（）；这个方法返回的就是迭代器的实现类对象

迭代器的使用步骤：

1.使用Collection集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口来接收

2.使用Iterator接口中的方法hasNext判断还有没有下一个元素

3.使用Iterator接口中的方法next取出集合的下一个元素

import java.util.*;
public class IteratorDemo{
public static void main(String[] args){
//可以使用多态来使用这个方法
Collection<String> collection = new ArrayList<>();
collection.add("李商隐");
collection.add("李清照");
collection.add("王安石");
collection.add("苏轼");
collection.add("白居易");
//使用迭代器取出集合中的元素
//首先要获得一个Iterator的实现类，可以使用方法iterator来获取
Iterator<String> aIterator = collection.iterator();
//判断集合有没有元素
while(aIterator.hasNext()){
String str = aIterator.next();
System.out.println(str);
}
}
}


增强for循环

Collection接口继承了Iterable接口，是JDK1.5之后出现的新特性。

格式

for(集合 变量名 ： 集合名){}

import java.util.*;
public class ForeachDemo{
public static void main(String[] args){
ArrayList<String> arraylist = new ArrayList<>();
arraylist.add("云想衣裳花想容， ");
arraylist.add("春风拂槛露华浓。 ");
arraylist.add("若非群玉山头见，");
arraylist.add("会向瑶台月下逢。 ");for(String a : arraylist){
System.out.println(a);
}
}
}


泛型

泛型是一种未知的数据类型

定义含有泛型的类

public class GenericDemo<E>{
private E e;public void setName(E e){
this.e = e;
} public E getName(){
return e;
}
}


public class GenericDemoa{
public static void main(String[] args){
GenericDemo<String> gd = new GenericDemo<>();
gd.setName("李白");
String str = gd.getName();
System.out.println(str);
}
}


//定义含有泛型的方法
public class GenericDemob{
public <E> void method1(E e){
System.out.println(e);
}public static <E> void method2(E e){
System.out.println(e);
}
}


public class GenericDemoc{
public static void main(String[] args){
GenericDemo1 gd1 = new GenericDemo1();
gd1.method1(123);
gd1.method1("云想衣裳花想容");
gd1.method1(8.8);GenericDemo1.method2("春风拂槛露华浓");
}
}


泛型通配符

public static void main(String[] args){ Collection<Integer> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<>(Number);
Collection<Object> list4 = new ArrayList<Object>();
/*
类与类之间的继承关系 Integer extends Number extends Object String extends Objects
*/
getElement1(list1);//编译通过，是Number的子类
getElement1(list2);//报错,不是Number的子类
getElement1(list3);//编译通过，是Number本身
getElement1(list4);//报错，不是Number的子类 getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);{
}
//泛型的上限：此泛型？，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
//泛型的下限：此泛型？ ，必须是Number类型或者Number类型的父类
public static void getElenment2(Collection<? super Number> coll)


做了一个斗地主的游戏，这个案例分析是看视频的，看完分析后，代码是我自己写的，写的好差，想的也久，写了2个小时了吧，终于完成了

package demo12;import java.util.ArrayList;
//做一个斗地主的游戏，有3个玩家，一个底牌
public class doudizhu {
public static void main(String[] args) {
//创建玩家集合，包含了底牌
Players aplayers = new Players();
//这个集合用来装54张牌
ArrayList<String> pokerArray = new ArrayList<>();
//这个集合用来装牌的颜色，装好了之后，要跟牌的号码进行组合
ArrayList<String> color = new ArrayList<String>();
color.add("♠");
color.add("♥");
color.add("♣");
color.add("♢");
//这个集合用来装扑克牌的数字
ArrayList<String> number = new ArrayList<String>();
number.add("2");
number.add("A"); //生成扑克牌
for (int i = 2; i < 13; i++) {
int j = i + 1;
String str = j + "";
number.add(str);
}
for (int i = 0; i < color.size(); i++) {
for (int j = 0; j < number.size(); j++) {
String str1 = color.get(i) + number.get(j);
pokerArray.add(str1);
}
}
//把大小王添加到pokerArray集合中去，到这里牌生成完毕
pokerArray.add(0, "大王");
pokerArray.add(1, "小王");
//传递集合
aplayers.play(pokerArray);
}}

import java.util.ArrayList;
import java.util.Collections;public class Players {
public void play(ArrayList<String> arrayList) {
//把传进来的集合打乱排序
Collections.shuffle(arrayList);
//玩家的集合
ArrayList<String> player1 = new ArrayList<String>();
ArrayList<String> player2 = new ArrayList<String>();
ArrayList<String> player3 = new ArrayList<String>();
ArrayList<String> player4 = new ArrayList<String>();
//发牌
for(int i=0;i<arrayList.size();i++) {
//为什么要减三，因为要把三张牌添加到底牌去，把索引51,52,53的牌添加到底牌去
if(i%3==0&&i<arrayList.size()-3){
String p1=arrayList.get(i);
player1.add(p1);
}else if(i%3==1&&i<arrayList.size()-2){
String p2 =arrayList.get(i);
player2.add(p2);
}else if(i%3==2&&i<arrayList.size()-2){
String p3 = arrayList.get(i);
player3.add(p3);
}else{
String p4 = arrayList.get(i);
player4.add(p4);
}
}
//显示牌
System.out.println(player1);
System.out.println(player2);
System.out.println(player3);
System.out.println(player4);
}
}

数据机构

栈：先进后出，只有一个入口和出口

队列：先进先出，一个入口，一个出口

数组：数组中的地址是连续的 ，可以直接根据索引值查询，，查询快，增删慢

链表：查询慢：链表中的地址不是连续的，每次查询都必须从头开始查询

增删快：链表结构，增加或删除一个元素，对链表的整体结构没有影响，所以增删快

红黑树:查询速度非常快

List集合

`

import java.util.*;
//List集合继承自Collection接口
//List集合是一个有序的集合，存进去的是1，2，3取出来的也是1，2，3
//List集合可以存储重复的元素
//List集合是一个带索引的集合
public class ListDemo{
public static void main(String[] args){
//看一看List集合的常用方法吧
//List集合是一个接口需要使用多态来调用其方法
List<String> aList = new ArrayList<>();
aList.add("云想衣裳花想容, ");
aList.add(" 春风拂槛露华浓。");
aList.add("若非群玉山头见， ");
//将指定的元素，添加都改集合中的指定位置上
aList.add(3,"会向瑶台月下逢。 ");
//返回集合中指定位置的元素
String str1 = aList.get(0);
System.out.println(str1);
//移除列表中指定位置的元素，返回的是被移除的元素
String str2 = aList.remove(1);
System.out.println(str2);
//用指定元素替换集合中指定位置的元素，返回值的更新前的元素
String str3 = aList.set(1,"春风不度玉门关");
System.out.println(str3);
System.out.println(aList);//[云想衣裳花想容, , 春风不度玉门关, 会向瑶台月下逢。 ]//遍历集合
for(int i = 0;i<aList.size();i++){
String str = aList.get(i);
System.out.println(str);
}//迭代器List集合的iterator方法会返回一个Iterator接口的实现类
Iterator<String> iterator = aList.iterator();
//先判断有没有下一个元素
while(iterator.hasNext()){
String str5 = iterator.next();
System.out.println(str5);
}for(String s : aList){
System.out.println(s);
}}
}


List集合的子类

ArrayList集合：元素增删慢，查找快，看用于查询数据，遍历数据

LinkedList集合：

LinkedList集合的常用方法

addFirst(E e);将指定元素插入列表开头

addLast(E e);将指定元素添加到列表结尾

push（E e）；将元素推入次列表所表示的堆栈，相等于addFirst

getFirst();返回次列表的第一个元素

getLast();返回此列表的最后一个元素

removeFirst();移除此列表的第一个元素

removeLast（）；移除此列表的最后一个元素

pop();等效于removeFirst

isEmpty();判断集合是否包含元素，有则返回false，没有则true