JAVA语言之详记基础进阶内容-职坐标

JAVA语言之详记基础进阶内容

从安 2019-06-05 来源：阅读 882 评论 0

摘要：本篇文章主要讲述JAVA语言之详记基础进阶内容，希望阅读本篇文章以后大家有所收获，帮助大家对相关内容的理解更加深入。

本篇文章主要讲述JAVA语言之详记基础进阶内容，希望阅读本篇文章以后大家有所收获，帮助大家对相关内容的理解更加深入。

JAVA语言之详记基础进阶内容

Collection集合

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

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

集合框架

import java.util.Collection;
import java.util.ArrayList;
//Collection的常用方法
public class CollectionDemo{
    public static void main(String[] args){
    //Collection是一个接口无法创建对象，可以使用多态来使用方法
    Collection 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 collection = new ArrayList<>();
    collection.add("李商隐");
    collection.add("李清照");
    collection.add("王安石");
    collection.add("苏轼");
    collection.add("白居易");
    //使用迭代器取出集合中的元素
    //首先要获得一个Iterator的实现类，可以使用方法iterator来获取
    Iterator 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 arraylist = new ArrayList<>();
    arraylist.add("云想衣裳花想容， ");
    arraylist.add("春风拂槛露华浓。 ");
    arraylist.add("若非群玉山头见，");
    arraylist.add("会向瑶台月下逢。 ");
    
    for(String a : arraylist){
        System.out.println(a);
    }
    }
}

泛型

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

定义含有泛型的类

public class GenericDemo{
    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 gd = new GenericDemo<>();
    gd.setName("李白");
    String str = gd.getName();
    System.out.println(str);
    }
}
//定义含有泛型的方法
public class GenericDemob{
    public  void method1(E e){
        System.out.println(e);
    }
    
    public static  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 list1 = new ArrayList();
     Collection list2 = new ArrayList();
     Collection list3 = new ArrayList<>(Number);
     Collection list4 = new ArrayList();
    /*
    类与类之间的继承关系 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 coll){}
   //泛型的下限：此泛型？ ，必须是Number类型或者Number类型的父类
public static void getElenment2(Collection coll)
做了一个斗地主的游戏，这个案例分析是看视频的，看完分析后，代码是我自己写的，写的好差，想的也久，写了2个小时了吧，终于完成了
package demo12;
import java.util.ArrayList;
//做一个斗地主的游戏，有3个玩家，一个底牌
public class doudizhu {
    public static void main(String[] args) {
        //创建玩家集合，包含了底牌
        Players aplayers = new Players();
        //这个集合用来装54张牌
        ArrayList pokerArray = new ArrayList<>();
        //这个集合用来装牌的颜色，装好了之后，要跟牌的号码进行组合
        ArrayList color = new ArrayList();
        color.add("♠");
        color.add("♥");
        color.add("♣");
        color.add("♢");
        //这个集合用来装扑克牌的数字
        ArrayList number = new ArrayList();
        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 arrayList) {
        //把传进来的集合打乱排序
        Collections.shuffle(arrayList);
        //玩家的集合
        ArrayList player1 = new ArrayList();
        ArrayList player2 = new ArrayList();
        ArrayList player3 = new ArrayList();
        ArrayList player4 = new ArrayList();
        //发牌
        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 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 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