笔记-迎难而上之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