java基础第七讲——集合、泛型、枚举、网络

目录

集合
泛型
枚举
网络

集合

Collection
Map
Collections

Collection

List
Set

List

ArrayList

// 测试ArrayList的方法
    public static void arrayListTest() {
        // ArrayList无法放简单数据类型
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("King");
        arrayList.add("WZ");
        arrayList.add("JXX");
        System.out.println(arrayList.size());
        System.out.println(arrayList.get(2));
        arrayList.add(1, "L");
        arrayList.set(1, "O");
        System.out.println(arrayList.get(1));
        System.out.println(arrayList.get(2));
        for (String i : arrayList) {
            System.out.print(i+" ");
        }
    }

结果

LinkedList 链结构

// 测试LinkedList的方法
    public static void linkedListTest() {
        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        System.out.println(linkedList.size());
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.contains("w"));//判断是否存在"w"
        linkedList.addFirst("we");
        System.out.println(linkedList.get(0));
        for (String l : linkedList) {
            System.out.print(l+" ");
        }
    }

Set

Set不允许有重复的

hashSet

hashSet是无序的

// 测试HashSet的方法
    public static void hashSetTest() {
        HashSet<Integer> hashSet = new HashSet<>();
        Random random = new Random();
        int count = 0;
        while (hashSet.size() < 10) {
            int i = random.nextInt(90) + 10;
            System.out.println(count++ + "随即放了" + i);
            hashSet.add(i);
        }
        System.out.println("长度"+hashSet.size());
        Iterator<Integer> it = hashSet.iterator();
        while (it.hasNext()) {
            System.out.print(it.next()+" ");
        }
    }

结果：（因为不允许重复有时会看到输出多一个）

TreeSet

查看API

Map

注意其中的iterator() 迭代器

if (it.hasNext()) {
            String k = it.next();
            System.out.println(hashMap.get(k).getName());
        }

    // 测试hashmap的方法
    public static void hashMapTest() {
        HashMap<String, Student> hashMap = new HashMap<>();
        Student zhangsan = new Student("张三",19);
        String name = "张三";
        hashMap.put(name, zhangsan);
        hashMap.put("lisi", new Student("李四",20));
        System.out.println(hashMap.size());
        System.out.println(hashMap.get(name).getName());
        Set<String> keys = hashMap.keySet();// 先得到hashmap的key值set
        Iterator<String> it = keys.iterator();// 得到set的迭代器
        if (it.hasNext()) {
            String k = it.next();
            System.out.println(hashMap.get(k).getName());
        }
    }

结果

Collections

// 测试Collections的方法
    public static void collectionsTest() {
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(new Student("张三", 18));
        arrayList.add(new Student("李四", 15));
        arrayList.add(new Student("王五", 20));
        arrayList.add(new Student("赵六", 13));
        arrayList.add(new Student("小明", 22));
        for (Student student : arrayList) {
            System.out.println(student.getName() + student.getAge());
        }
        System.out.println();
        Collections.sort(arrayList, new StuComparator());// 排序 需要构建一个比较器
        for (Student student : arrayList) {
            System.out.println(student.getName() + student.getAge());
        }
    }

import java.util.Comparator;

//自定义比较器
public class StuComparator implements Comparator<Student> {
    @Override
    public int compare(Student stu1, Student stu2) {
        return stu1.getAge() - stu2.getAge();
    }
}

结果

泛型

例：学生类中学生所穿的衣服、自己的宠物，有的穿男士衣服，有的穿女士衣服。在创建一个对象时，无法精确得到衣服的类别，只是用泛型。

//多个泛型用","隔开，可以继承
public class Student<T,E extends Pet> {
    private String name;
    private T clothes;
    private E pet;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public T getClothes() {
        return clothes;
    }
    public void setClothes(T clothes) {
        this.clothes = clothes;
    }
    public E getPet() {
        return pet;
    }
    public void setPet(E pet) {
        this.pet = pet;
    }
}

//省略了男、女衣服类和宠物类及其子类

public class Test {
    public static void main(String[] args) {
        Student<MenClothes,Dog> zhangsan = new Student<>();
        MenClothes clothes = new MenClothes();
        Dog dog = new Dog();
        zhangsan.setClothes(clothes);
        zhangsan.setPet(dog);
        Student<FemanClothes, Cat> xiaohong = new Student<>();
        FemanClothes femanClothes = new FemanClothes();
        Cat cat = new Cat();
        xiaohong.setClothes(femanClothes);
        xiaohong.setPet(cat);
//      不是继承于Pet的类会报错
//      Student<MenClothes, String> lilei = new Student<>();
    }
}

枚举

相当于 public static final

/**
 * 设置性别枚举类
 * @author Administrator
 *
 */
public enum Sex {
    FEMALE,MALE
}
public class Student {
    private Sex sex;

    public Sex getSex() {
        return sex;
    }

    public void setSex(Sex sex) {
        this.sex = sex;
    }
}
public class Test {
    public static void main(String[] args) {
        Student zhangsan = new Student();
        zhangsan.setSex(Sex.MALE);
        switch (zhangsan.getSex()) {
        case MALE:
            System.out.println("此同学为男生");
            break;
        case FEMALE:
            System.out.println("此同学为女生");
            break;
        default:
            break;
        }
    }
}

网络

TCP/IP协议
UDP协议

网络工作模式
专用的服务器结构（Server—Based）BS结构
客户机/服务器模式（Client/Server）CS结构
对等式网络：P2P（Peer-to-Peer）

import java.net.InetAddress;
import java.net.UnknownHostException;

public class Test {
    public static void main(String[] args) {
        hostIp();
    }
    public static void hostIp() {
        try {
            // InetAddress无法new一个对象 通过类名.
            InetAddress address = InetAddress.getLocalHost();
            System.out.println("主机名:" + address.getHostName());
            System.out.println("本机IP地址:" + address.getHostAddress());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

结果

TCP/IP协议

serverSocket （服务器端）
Socket（客户端） 返回的是套接字，可以输出
accept() 服务器等待连接

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**
 * 服务器端 先开启服务器端
 * 
 * @author Administrator
 *
 */
public class MyServer {
    public static void main(String[] args) {
        try {
            // 创建一个服务器
            ServerSocket server = new ServerSocket(8080);
            System.out.println("服务器已启动");
            // accept让服务器等待连接返回一个套接字
            Socket socket = server.accept();
            // 服务端的输出流
            OutputStream os = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(os);
            BufferedWriter bw = new BufferedWriter(osw);
            // 服务端的输入流
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            Scanner scanner = new Scanner(System.in);
            while (true) {
                String s = br.readLine();// 等待客户端来数据
                System.out.println("客户端：" + s);
                String back = scanner.next();
                bw.write(back + "\n");
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Scanner;

/**
 * 客户端
 * 
 * @author Administrator
 *
 */
public class MyClient {
    public static void main(String[] args) {
        try {
            System.out.println("客户端已启动");
                Socket socket = new Socket("192.***.*.**", 8080);//参数：前边是IP地址，后边是端口
            // 客户端的输出流
            OutputStream os = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(os);
            BufferedWriter bw = new BufferedWriter(osw);
            // 客户端的输入流
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            Scanner scanner = new Scanner(System.in);
            while (true) {
                String s = scanner.next();
                bw.write(s + "\n");
                bw.flush();
                String back = br.readLine();
                System.out.println("服务器：" + back);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

结果

UDP协议

DatagramSocket

/**
 * Receiver 先接收后发送
 * @author Administrator
 *
 */
public class ReceiverTest {
    public static void main(String[] args) {
        try {
            DatagramSocket receiver = new DatagramSocket(8080);
            DatagramSocket send = new DatagramSocket();
            byte[] array = new byte[1024];
            Scanner scanner = new Scanner(System.in);
            while (true) {
                //接收
                DatagramPacket receiverPacket = new DatagramPacket(array, array.length);
                receiver.receive(receiverPacket);
                //接收时用包的长度，如果数组的旧数据大小比新数据大，用数组长度会出现重复信息
                System.out.println("Send说:"+ new String(array,0,receiverPacket.getLength()));

                //发送
                byte[] data = scanner.next().getBytes();
                DatagramPacket sendPacket = new DatagramPacket(data, data.length,InetAddress.getLocalHost(),8081);
                send.send(sendPacket);
            }
        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
/**
 * Send  先发送后接收
 * @author Administrator
 *
 */
public class SendTest {
    public static void main(String[] args) {
        try {
            DatagramSocket send = new DatagramSocket();
            DatagramSocket receiver = new DatagramSocket(8081);
            byte[] array = new byte[1024];
            Scanner scanner = new Scanner(System.in);
            while (true) {
                //发送
                byte[] data = scanner.next().getBytes();
                DatagramPacket sendpacket = new DatagramPacket(data, data.length, InetAddress.getLocalHost(),8080);
                send.send(sendpacket);

                //接收
                DatagramPacket receiverpacket = new DatagramPacket(array, array.length);
                receiver.receive(receiverpacket);
                System.out.println("Receiver说："+ new String(array,0,receiverpacket.getLength()));
            }
        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}