千鋒逆戰班，JavaSE結束項目學生信息管理系統

學習java第36天
Se階段結束了，最後一個小項目。更新完成

這裏寫自定義目錄標題

程序啓動

package com.qf.project.menu;

import java.util.Scanner;

import com.qf.project.entity.Student;
import com.qf.project.service.StudentService;
import com.qf.project.manager.*;
public class SystemMain {
	private static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		
		StudentService ss = new StudentService();

		for(int i = 0;i<10;i++) {
			String name = "吳彥祖"+i;
			int age = (int)(Math.random() *50);
			char sex = '男';
			String className = "NZ2002";
			double javaScore = (double)(Math.random() *100);
			double htmlScore = (double)(Math.random() *100);
			double springScore = (double)(Math.random() *100);
			ss.addStudent(new Student(name,age,sex,className,javaScore,htmlScore,springScore));
		}
		while(true){
			System.out.println("歡迎來到千鋒學員管理系統");
			System.out.println("1.查看所有學員");
			System.out.println("2.新增學員");
			System.out.println("3.查詢指定ID的學生信息");
			System.out.println("4.根據ID刪除學員");
			System.out.println("5.根據ID修改學員信息");
			System.out.println("6.根據班級名稱查詢學員");
			System.out.println("7.根據姓名（姓、名）查詢學員");
			System.out.println("8.根據需求排序學員信息");
			System.out.println("9.根據需求展示符合條件的學員信息");
			System.out.println("0.退出！");
			System.out.println("請選擇：");
			
			int choice = sc.nextInt();
			
			switch(choice){
			case 1:
				ss.show();
				break;
			case 2:
				ss.addStudent();
				break;
			case 3:
				ss.getStuById();
				break;
			case 4:
				ss.delStuById();
				break;
			case 5:
				ss.setStuInId();
				break;
			case 6:
				ss.getStuByClassName();
				break;
			case 7:
				ss.getStuBySurName();
				break;
			case 8:
				ss.sortStu();
				break;
			case 9:
				ss.showFilter();
				break;
			case 0:
				ss.aa();
				return;
				default:
					break;
			
			
			
			
			}
			
			
		}
		
		
	}

}

StudentService

package com.qf.project.util.impl;

import java.util.Arrays;

import com.qf.project.util.MyList;

public class MyArrayList<E> implements MyList<E> {
	//1.保存任意類型數據的數組，集合的底層
	private Object[] elmentData = null;
	//2.集合初始容量
	private static final int DEFAULT_CAPACITY=10;
	//3.保存數組中有效元素個數 (下一個元素插入的下標)
	private int size = 0;
	
	
	
	
	public MyArrayList() {
		//調用無參的構造方法會直接牀架一個容量爲10的數組
		this(DEFAULT_CAPACITY);
	}
	
	public MyArrayList(int in) {
		if(in < 0 || in > Integer.MAX_VALUE-8){
			throw new IllegalArgumentException("傳遞了一個不符合規範的初始容量！："+in);
		}else{
			elmentData = new Object[in];
		}
	}
	/**
	 * 爲底層數組elementData做擴容！
	 * @param minCapacity 擴容需要得最小容量！
	 */
	public void grow(){
		int oldCapacity = elmentData.length;
		int newCapacity = oldCapacity + (oldCapacity>>1);
		if(newCapacity > Integer.MAX_VALUE-8){
			throw new OutOfMemoryError("集合溢出了！");
		}
		if(newCapacity == 0){
			newCapacity = size+1;
		}
		/*
		 * 1、創建新數組
		 * 2.拷貝元數據到新數組
		 * 3.返回新數組的首地址
		 * 4，替換
		 */
		elmentData = Arrays.copyOf(elmentData, newCapacity);
	}

	@Override
	public boolean add(E e) {
		if(size == elmentData.length){
			grow();
		}
		elmentData[size] = e;
		size++;
		return true;
	}
	
	
	
	@Override
	public boolean add(int index, E e) {
		checkIndex(index);//判斷下標是否合法
		if(size == elmentData.length){
			grow();
		}
		for(int i = size;i > index;i--){
			elmentData[i] = elmentData[i-1];
		}
		elmentData[index] = e;
		size++;
		return true;
	}
	/**
	 * 指定下標的安全檢查！如果下標值不符合要求，拋異常
	 * @param index  下標
	 */
	private void checkIndex(int index) {
		if(index<0 ||index >=size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}
	@Override
	public E remove(Object o) {
		if(o == null){
			throw new NullPointerException("元素爲空");
		}
		for(int i = 0; i< size;i++){
//			E e1 = (E)elmentData[i];
//			E e2 = (E)o;
//			if(e1.equals(e2)){
			if(elmentData[i].equals(o)){
//				System.out.println(elmentData[i]);
				for(int j = i;j<size-1;j++){
					elmentData[j] = elmentData[j+1];//往前覆蓋，但是最後一個沒有被覆蓋（考慮數組長度和有效元素個數會相同）
				}
				elmentData[size-1] = null;//循環完事單獨吧最後一個有效元素覆蓋null
				size--;
				return (E)o;
			}
		}
		
		return null;
	}

	@Override
	public E remove(int index) {
		checkIndex(index);
		Object o1 = elmentData[index];
		for(int i=index;i< size-1;i++){
			elmentData[i] = elmentData[i+1];//往前覆蓋，但是最後一個沒有被覆蓋（考慮數組長度和有效元素個數會相同,最後一個會出現下標越界錯誤）
		}
		elmentData[size-1] = null;//循環完事單獨吧最後一個有效元素覆蓋null
		size--;
		return (E)o1;
	}

	@Override
	public E set(int index, E e) {
		checkIndex(index);
		
		
		return (E)(elmentData[index] = e);
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public Object[] toArray() {
		Object[] o = new Object[size];
		for(int i = 0;i<size;i++){
			o[i]=elmentData[i];
		}
		return o;
	}

	@Override
	public boolean isEmpty() {
		if(elmentData == null){
			return true;
		}
		if(size ==0){
			return true;
		}
		return false;
	}

	@Override
	public boolean contains(Object o) {
		for(int i =0;i < size ;i++){
			if(elmentData[i].equals(o)){
				return true;
			}
		}
		return false;
	}

	@Override
	public MyList<E> subList(int start, int end) {
		checkIndex(start);
		checkIndex(end);
		if(start < end){
			MyList<E> m = new MyArrayList<E>();
			for(int i = start ; i <=end ;i++){
				m.add((E)elmentData[i]);
			}
			return m;
		}
		if(start >= end){
			throw new ArrayIndexOutOfBoundsException("開始大於了終止的下標");
		}
		return null;
	}

	@Override
	public int indexOf(Object o) {
		for(int i = 0;i<size;i++){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public int lastIndexOf(Object o) {
		for(int i =size-1;i >= 0;i--){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public E get(int index) {
		checkIndex(index);//檢查下標是否合法範圍
		return (E)elmentData[index];
	}

}

Student

package com.qf.project.entity;

import java.io.Serializable;

public class Student implements Serializable {
	private int id;//學號
	private String name;//姓名
	private int age;//年齡
	private char sex;//性別
	private String className;//班級
	private double javaScore;//Java成績
	private double htmlScore;//html成績
	private double springScore;//spring成績
	private double totalScore;//總分
	
	public static int count =0;
	//無參
	public Student() {
	
	}
	//無成績有參   基本信息
	public Student(String name,int age,char sex,String className){
		count++;
		this.id = count;
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.className = className;
		
	}
	//有成績有參構造 
	public Student(String name, int age, char sex, String className, double javaScore, double htmlScore,
			double springScore) {
		this(name,age,sex,className);
		this.javaScore = javaScore;
		this.htmlScore = htmlScore;
		this.springScore = springScore;
		this.totalScore = javaScore + htmlScore + springScore;
	}
	public int getId() {
		return id;
	}
	
	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;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public String getClassName() {
		return className;
	}
	public void setClassName(String className) {
		this.className = className;
	}
	public double getJavaScore() {
		return javaScore;
	}
	public void setJavaScore(double javaScore) {
		this.totalScore -= this.javaScore;//先把原來的java成績減掉。
		
		this.javaScore = javaScore;//正常賦值
		
		this.totalScore += javaScore;//將更新好的成績重新加到總分中
	}
	public double getHtmlScore() {
		return htmlScore;
	}
	public void setHtmlScore(double htmlScore) {
		this.totalScore -= this.htmlScore;//將原來的html成績從總分去除
		
		this.htmlScore = htmlScore;//將最新的成績更新
		
		this.totalScore += htmlScore;//將更新好的成績重新加到總分中
	}
	public double getSpringScore() {
		return springScore;
	}
	public void setSpringScore(double springScore) {
		this.totalScore -= this.springScore;//將原來的spring成績從總分去除
		
		this.springScore = springScore;//將最新的成績更新
		
		this.totalScore += springScore;//將更新好的成績重新加到總分中
	}
	//總分不能自己修改
	public double getTotalScore() {
		return totalScore;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", className=" + className
				+ ", javaScore=" + javaScore + ", htmlScore=" + htmlScore + ", springScore=" + springScore
				+ ", totalScore=" + totalScore + "]";
	}
	@Override
	public int hashCode() {
		
		return id;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (this.getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if(this.id == other.id && this.name.equals(other.name)&&this.age == other.age && this.sex == other.sex
				&& this.className.equals(other.className)&&this.javaScore==other.javaScore&&this.htmlScore==other.htmlScore
				&&this.springScore == other.springScore){
			return true;
			
		}
				
		return false;
	}
	
	
	
	
}

StudentManager

package com.qf.project.util.impl;

import java.util.Arrays;

import com.qf.project.util.MyList;

public class MyArrayList<E> implements MyList<E> {
	//1.保存任意類型數據的數組，集合的底層
	private Object[] elmentData = null;
	//2.集合初始容量
	private static final int DEFAULT_CAPACITY=10;
	//3.保存數組中有效元素個數 (下一個元素插入的下標)
	private int size = 0;
	
	
	
	
	public MyArrayList() {
		//調用無參的構造方法會直接牀架一個容量爲10的數組
		this(DEFAULT_CAPACITY);
	}
	
	public MyArrayList(int in) {
		if(in < 0 || in > Integer.MAX_VALUE-8){
			throw new IllegalArgumentException("傳遞了一個不符合規範的初始容量！："+in);
		}else{
			elmentData = new Object[in];
		}
	}
	/**
	 * 爲底層數組elementData做擴容！
	 * @param minCapacity 擴容需要得最小容量！
	 */
	public void grow(){
		int oldCapacity = elmentData.length;
		int newCapacity = oldCapacity + (oldCapacity>>1);
		if(newCapacity > Integer.MAX_VALUE-8){
			throw new OutOfMemoryError("集合溢出了！");
		}
		if(newCapacity == 0){
			newCapacity = size+1;
		}
		/*
		 * 1、創建新數組
		 * 2.拷貝元數據到新數組
		 * 3.返回新數組的首地址
		 * 4，替換
		 */
		elmentData = Arrays.copyOf(elmentData, newCapacity);
	}

	@Override
	public boolean add(E e) {
		if(size == elmentData.length){
			grow();
		}
		elmentData[size] = e;
		size++;
		return true;
	}
	
	
	
	@Override
	public boolean add(int index, E e) {
		checkIndex(index);//判斷下標是否合法
		if(size == elmentData.length){
			grow();
		}
		for(int i = size;i > index;i--){
			elmentData[i] = elmentData[i-1];
		}
		elmentData[index] = e;
		size++;
		return true;
	}
	/**
	 * 指定下標的安全檢查！如果下標值不符合要求，拋異常
	 * @param index  下標
	 */
	private void checkIndex(int index) {
		if(index<0 ||index >=size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}
	@Override
	public E remove(Object o) {
		if(o == null){
			throw new NullPointerException("元素爲空");
		}
		for(int i = 0; i< size;i++){
//			E e1 = (E)elmentData[i];
//			E e2 = (E)o;
//			if(e1.equals(e2)){
			if(elmentData[i].equals(o)){
//				System.out.println(elmentData[i]);
				for(int j = i;j<size-1;j++){
					elmentData[j] = elmentData[j+1];//往前覆蓋，但是最後一個沒有被覆蓋（考慮數組長度和有效元素個數會相同）
				}
				elmentData[size-1] = null;//循環完事單獨吧最後一個有效元素覆蓋null
				size--;
				return (E)o;
			}
		}
		
		return null;
	}

	@Override
	public E remove(int index) {
		checkIndex(index);
		Object o1 = elmentData[index];
		for(int i=index;i< size-1;i++){
			elmentData[i] = elmentData[i+1];//往前覆蓋，但是最後一個沒有被覆蓋（考慮數組長度和有效元素個數會相同,最後一個會出現下標越界錯誤）
		}
		elmentData[size-1] = null;//循環完事單獨吧最後一個有效元素覆蓋null
		size--;
		return (E)o1;
	}

	@Override
	public E set(int index, E e) {
		checkIndex(index);
		
		
		return (E)(elmentData[index] = e);
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public Object[] toArray() {
		Object[] o = new Object[size];
		for(int i = 0;i<size;i++){
			o[i]=elmentData[i];
		}
		return o;
	}

	@Override
	public boolean isEmpty() {
		if(elmentData == null){
			return true;
		}
		if(size ==0){
			return true;
		}
		return false;
	}

	@Override
	public boolean contains(Object o) {
		for(int i =0;i < size ;i++){
			if(elmentData[i].equals(o)){
				return true;
			}
		}
		return false;
	}

	@Override
	public MyList<E> subList(int start, int end) {
		checkIndex(start);
		checkIndex(end);
		if(start < end){
			MyList<E> m = new MyArrayList<E>();
			for(int i = start ; i <=end ;i++){
				m.add((E)elmentData[i]);
			}
			return m;
		}
		if(start >= end){
			throw new ArrayIndexOutOfBoundsException("開始大於了終止的下標");
		}
		return null;
	}

	@Override
	public int indexOf(Object o) {
		for(int i = 0;i<size;i++){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public int lastIndexOf(Object o) {
		for(int i =size-1;i >= 0;i--){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public E get(int index) {
		checkIndex(index);//檢查下標是否合法範圍
		return (E)elmentData[index];
	}

}

	
}

MyArrayList

package com.qf.project.util.impl;

import java.util.Arrays;

import com.qf.project.util.MyList;

public class MyArrayList<E> implements MyList<E> {
	//1.保存任意類型數據的數組，集合的底層
	private Object[] elmentData = null;
	//2.集合初始容量
	private static final int DEFAULT_CAPACITY=10;
	//3.保存數組中有效元素個數 (下一個元素插入的下標)
	private int size = 0;
	
	
	
	
	public MyArrayList() {
		//調用無參的構造方法會直接牀架一個容量爲10的數組
		this(DEFAULT_CAPACITY);
	}
	
	public MyArrayList(int in) {
		if(in < 0 || in > Integer.MAX_VALUE-8){
			throw new IllegalArgumentException("傳遞了一個不符合規範的初始容量！："+in);
		}else{
			elmentData = new Object[in];
		}
	}
	/**
	 * 爲底層數組elementData做擴容！
	 * @param minCapacity 擴容需要得最小容量！
	 */
	public void grow(){
		int oldCapacity = elmentData.length;
		int newCapacity = oldCapacity + (oldCapacity>>1);
		if(newCapacity > Integer.MAX_VALUE-8){
			throw new OutOfMemoryError("集合溢出了！");
		}
		if(newCapacity == 0){
			newCapacity = size+1;
		}
		/*
		 * 1、創建新數組
		 * 2.拷貝元數據到新數組
		 * 3.返回新數組的首地址
		 * 4，替換
		 */
		elmentData = Arrays.copyOf(elmentData, newCapacity);
	}

	@Override
	public boolean add(E e) {
		if(size == elmentData.length){
			grow();
		}
		elmentData[size] = e;
		size++;
		return true;
	}
	
	
	
	@Override
	public boolean add(int index, E e) {
		checkIndex(index);//判斷下標是否合法
		if(size == elmentData.length){
			grow();
		}
		for(int i = size;i > index;i--){
			elmentData[i] = elmentData[i-1];
		}
		elmentData[index] = e;
		size++;
		return true;
	}
	/**
	 * 指定下標的安全檢查！如果下標值不符合要求，拋異常
	 * @param index  下標
	 */
	private void checkIndex(int index) {
		if(index<0 ||index >=size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}
	@Override
	public E remove(Object o) {
		if(o == null){
			throw new NullPointerException("元素爲空");
		}
		for(int i = 0; i< size;i++){
//			E e1 = (E)elmentData[i];
//			E e2 = (E)o;
//			if(e1.equals(e2)){
			if(elmentData[i].equals(o)){
//				System.out.println(elmentData[i]);
				for(int j = i;j<size-1;j++){
					elmentData[j] = elmentData[j+1];//往前覆蓋，但是最後一個沒有被覆蓋（考慮數組長度和有效元素個數會相同）
				}
				elmentData[size-1] = null;//循環完事單獨吧最後一個有效元素覆蓋null
				size--;
				return (E)o;
			}
		}
		
		return null;
	}

	@Override
	public E remove(int index) {
		checkIndex(index);
		Object o1 = elmentData[index];
		for(int i=index;i< size-1;i++){
			elmentData[i] = elmentData[i+1];//往前覆蓋，但是最後一個沒有被覆蓋（考慮數組長度和有效元素個數會相同,最後一個會出現下標越界錯誤）
		}
		elmentData[size-1] = null;//循環完事單獨吧最後一個有效元素覆蓋null
		size--;
		return (E)o1;
	}

	@Override
	public E set(int index, E e) {
		checkIndex(index);
		
		
		return (E)(elmentData[index] = e);
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public Object[] toArray() {
		Object[] o = new Object[size];
		for(int i = 0;i<size;i++){
			o[i]=elmentData[i];
		}
		return o;
	}

	@Override
	public boolean isEmpty() {
		if(elmentData == null){
			return true;
		}
		if(size ==0){
			return true;
		}
		return false;
	}

	@Override
	public boolean contains(Object o) {
		for(int i =0;i < size ;i++){
			if(elmentData[i].equals(o)){
				return true;
			}
		}
		return false;
	}

	@Override
	public MyList<E> subList(int start, int end) {
		checkIndex(start);
		checkIndex(end);
		if(start < end){
			MyList<E> m = new MyArrayList<E>();
			for(int i = start ; i <=end ;i++){
				m.add((E)elmentData[i]);
			}
			return m;
		}
		if(start >= end){
			throw new ArrayIndexOutOfBoundsException("開始大於了終止的下標");
		}
		return null;
	}

	@Override
	public int indexOf(Object o) {
		for(int i = 0;i<size;i++){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public int lastIndexOf(Object o) {
		for(int i =size-1;i >= 0;i--){
			if(elmentData[i].equals(o)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public E get(int index) {
		checkIndex(index);//檢查下標是否合法範圍
		return (E)elmentData[index];
	}

}

接口：
MyFilter

package com.qf.project.util;

public interface MyFilter<E> {
	boolean accept(E e);
}

MyComparator

package com.qf.project.util;

public interface MyComparator<E> {
	/**
	 * 自定義排序的方法，方法的返回值是int類型
	 * @param stu1 student類型
	 * @param stu2 student類型
	 * @return >0 前者大於後者   <0 前者小於後者  ==0 兩者相同
	 */
	int compare(E e1,E e2);
}

MyList

package com.qf.project.util;
/**
 * 
 *  增加：
 * add(E e);
 * add(int index,E e);
 * 刪除：
 * remove(E e);
 * remove(int index);
 * 改：
 * set(int index,E e);
 * 獲取：
 * int size();
 * Object[] toArray();
 * boolean isEmpty();
 * boolean contains(Object o);
 * MyArrayList<E> subList(int start,int end);
 * int indexOf(Object o);
 * int lastIndexOf(Object o);
 * E get(int index);
 * @author Dell
 *
 * @param <E> 泛型，應用在不同類型下，作爲集合中元素的類型（傳入什麼類型就爲什麼類型）
 */


public interface MyList<E> {
	/**
	 * 添加方法
	 * 添加元素到集合末尾
	 * @param e 元素
	 * @return 添加成功返回true否則false
	 */
	boolean add(E e);
	
	/**
	 * 添加方法
	 * 將元素添加到指定的下標中
	 * @param index 集合元素的下標
	 * @param e 集合中元素
	 * @return  添加成功返回true否則false
	 */
	boolean add(int index ,E e);
	/**
	 * 
	 * 移除方法
	 * 移除指定元素
	 * @param o 要移除的元素
	 * @return 返回移除的元素
	 */
	E remove(Object o);
	/**
	 *移除方法
	 * 根據指定的下標移除下標上的元素
	 * @param index 將要移除元素的下標
	 * @return 返回移除的元素
	 */
	E remove(int index);
	
	/**
	 * 覆蓋方法，替換制定下標上的元素
	 * 
	 * @param index 下標
	 * @param e 替換的元素
	 * @return 被替換的元素
	 */
	E set(int index,E e);
	
	/**
	 *獲取集合中有效的元素個數
	 * 
	 * @return 有效元素個數
	 */
	int size();
	/**
	 * 獲取集合中，算有元素的Object類型數組
	 * 
	 * @return Object[] 集合元素數組
	 */
	Object[] toArray();
	
	/**
	 * 
	 * 判斷集合是否爲空
	 * @return 如果一個元素都沒有，返回true，有元素返回false
	 */
	boolean isEmpty();
	
	/**
	 * 判斷集合中是否有何傳入元素相同的元素
	 * @param o 需要查找的對象
	 * @return 有返回true，沒有返回false
	 */
	boolean contains(Object o);
	/**
	 * 根據需求，返回start到end之間的MyList集合的子集合
	 * @param start 要求有效下標的範圍，不能超過end
	 * @param end要求有效下標的範圍，不能小於等於start
	 * @return 數據符合要求，返回一個當前集合的子集合。若數據不符合要求，返回NULL
	 */
	MyList<E> subList(int start,int end);
	/**
	 * 獲得指定元素在集合中第一次出現的位置
	 * @param o 指定的元素
	 * @return 找到返回值 返回下標，沒找到返回-1
	 */
	int indexOf(Object o);
	/**
	 * 獲取指定元素在集合中最後一次出現的位置
	 * @param o指定的元素
	 * @return 找到返回值 返回下標，沒找到返回-1
	 */
	int lastIndexOf(Object o);
	/**
	 * 根據指定的下標位置，獲得元素
	 * @param index 下標
	 * @return 元素對象
	 */
	E get(int index);
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
}

千鋒逆戰班，JavaSE結束項目學生信息管理系統

這裏寫自定義目錄標題

[轉帖]使用NMT和pmap解決JVM資源泄漏問題原創

Python實現大麥網搶票的四大關鍵技術點解析

salesforce零基礎學習（一百三十八）零碎知識點小總結（十）

一款開源的.NET程序集反編譯、編輯和調試神器

關於接口協議，你必須要知道這些！

【2024-05-21】以茶會友

千鋒逆戰班，jdbc事務

學習java的第五週學習總結

千鋒逆戰班，多線程和高級多線程

千鋒逆戰班，Set和Map習題

千鋒逆戰班，final和接口習題

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結