java笔记

于 2021-03-19 16:23:30 发布
阅读量187 收藏
点赞数
分类专栏： java笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43389238/article/details/115009041
版权

创建空项目

在这里插入图片描述

位运算（效率高）

A = 0011 1100
B = 0000 1101
A&B = 0000 1100 //与：有0得0，全1得1
A|B = 0011 1101 //或：有1得1，全0得0
A^B = 0011 0001 //异或：相同、为0，不同为1
~B = 1111 0010 //取反
//左移右移：
2*8=16  ->   2<<3
//左移:<<   移1位= *2
//右移:>>   移1位= /2

字符串连接符

// 字符串连接符
int a = 10;
int b = 20;
System.out.println(a+b); //30
System.out.println(""+a+b); //1020，字符串在前，a，b会拼接
System.out.println(a+b+""); //30，字符串在后，a+b会计算

强制转换

		int money = 10_0000_0000;
        int day = 20;
        long total = money*day;
        System.out.println(total);//-1474836480
        long total1 = money*((long)day);
//        long total = ((long)money)*day;//两种方式均可
        System.out.println(total1);//20000000000

包

一般利用公司域名倒置作为包名，如：com.baidu.www

数据类型及其扩展

// 二进制 、 八进制0 、 十六进制0x
float a = 3.14F;//浮点数定义后面要加F
long i4 = 57L;//长整型定义后面要加L
int i2_1 = 010;//八进制
int i2_2 = 0x10;// 十六进制

基础数据类型

整型： byte short int long（长整形）
浮点型： float（单精度） double （双精度）
布尔值： boolean
字符型： char

取值范围

整型 ： byte -2^7 -> 2^7-1 10000000(-128) 其余的以此类推
浮点型 ： 符号位 + 阶码（指数） + 尾数
char 一个字符连个字节 （unicode）

强制转化

整型里边小转大自动转，大转小需要强转，应为可能会丢失精度
整型和浮点型：浮点型转整型需要强转，反之不需要，但是他以科学计数法表示可能会丢失精度
char能不能和整型转： 就是两个字节，随便转，就能当成一个short。但是char类型的变量经过计算都
是int。任何short,byte,int,char无论是逻辑运算还是数学运算结果都是int；

// 会保存，计算结果都是int 
byte m = 1; 
byte n = 3; 
byte c = m + n;

运算符

1.逻辑运算符

  • 与 ：& 全部为真才是真，有一个是假就是假 串联电路 1 & 1 = 1； 0 & 0 = 0 ； 1& 0 = 0
  • 或 ：| 全部为假才是假，有一个为真就是真 并联电路 1 | 1 = 1 ; 1 | 0 = 1; 0 | 0 = 0
  • 非 : ! 非真即使假，非假就是真
  • 异或： ^ 相同为假 ，不同为真 1^1 = 0 ; 0^0 = 0; 1^0 = 1
  • 双与（ &&）：短路运算符， 前边为假直接返回假，后边的就不进行计算了 （常用）
  • 双或 （ ||）：短路运算符， 前边为真直接返回真，后边的就不进行计算了（常用）

2.算术运算符

加 减 乘 除 取余（%）

3.赋值运算符

  • = ： 把后边的值赋给前边的变量

  • ++ ： 自加一 arr[i++] 选运算，先把i给arr算，然后i=i+1 ; arr[++i] 选i=i+1，先把i给arr ；

    arr[i+1] 就是一个值i不会变

  • – ： 自减一

  • += ： i += 6 如同与 i= i+6

  • -= ：i -= 6 如同与 i= i-6

4.位移运算符

  • >> 有符号右移 ,右移一位大致相当于什么除以2，除非溢出的末尾是零
  • << 有符号左移，右移一位大致相当于什么乘以2，溢出的首位是零
  • >>> 无符号右移

5.三目运算符

  • 条件 ？ 结果一 ： 结果二；

生成javadoc

在这里插入图片描述
在这里插入图片描述

通过命令行操作

进入文件所在目录，打开命令行输入：javadoc -encoding UTF-8 -charset UTF-8 Doc1.java，打开生成的index.html

通过idea操作

在这里插入图片描述
在这里插入图片描述

1.选择是整个项目还是模块还是单个文件
2.文档输出路径
3.Locale 选择地区，这个决定了文档的语言，中文就是zh_CN
4.传入JavaDoc的参数，一般这样写 -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/7/docs/api

在这里插入图片描述

注意：文件路径不能包含中文！！！

变量（实例变量，类变量，局部变量）

public class Hello {
    static int a = 0;//类变量
    
    String str = "hello world!";//实例变量
    
    public void method(){
        int i = 0;//局部变量
    }
}

Scanner用法

在这里插入图片描述
在这里插入图片描述

switch case

在这里插入图片描述

case后记者加break
switch支持字符串

反编译

java----class（字节码文件）-----反编译（idea就可以执行）

while跟do while

while先判断再循环，do while先执行再循环，循环体至少执行一次。

99乘法表

	static final int NUM = 9;
    for (int i = 1; i <= NUM; i++){
        for (int j = 1; j <= i;j++){
            System.out.print(i+"*"+j+"="+(i*j)+"\t");
        }
        System.out.println();
    }

选择1000内能被5整除的数并每行输出三个

int num = 0;//用于控制第三个换行
for (int i = 0; i <= 1000; i++) {
    if (i % 5 == 0){
        System.out.print(i+" ");
        num = num + 1;
        if (num % 3 == 0){//换行
            System.out.println();
        }
    }

增强for循环

java5引入了一种主要用于数组或者集合的增强型for循环

//创建一个数组
        int[] numbers = {10,20,30,40,50};
        for (int x:numbers){
            System.out.println(x);
        }

break、continue、goto

break用于强行退出循环

continue用于终止某次循环过程

goto是Java的保留字，但并未在java中使用：Java没有goto,但可以用带标签的break和continue表示goto

//101-150之间的所有质数
int count = 0;
outer:for (int i = 101; i < 150; i++) {
    for (int j = 2;j<i/2;j++){
        if (i % j == 0){
            continue outer;
        }
    }
    System.out.print(i+"\t");
}

打印三角形

for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }

            System.out.println();
}

方法

方法的重载

在这里插入图片描述

return 0;//表示终止方法

在这里插入图片描述

命令行传参

在这里插入图片描述
在这里插入图片描述

可变参数（不定长）

在这里插入图片描述
在这里插入图片描述

递归

在这里插入图片描述

数组

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Arrays方法

int[] array = {1, 10, 6, 9, 5,9,6,4};
System.out.println(Arrays.toString(array));//[1, 10, 6, 9, 5, 9, 6, 4]

int[] array = {1, 10, 6, 9, 5,9,6,4};
Arrays.fill(array,0);//将array的数值都赋为0
System.out.println(Arrays.toString(array));//[0, 0, 0, 0, 0, 0, 0, 0]

for (int i : array) {
	System.out.println(array);
}//增强for循环
for (int[] ints : array) {
            for (int anInt : ints) {
                
            }
        }//增强for循环二维数组

冒泡排序

public static int[] sort(int[] array){
    int temp = 0;//中间变量
    for (int i = 0; i < array.length-1; i++) {
        for (int j = i; j < array.length-1-i; j++) {
            if (array[j+1] > array[j]) {
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    return array;
}

插入排序

public class Insertsort {
    public static void main(String[] args) {
        int[] array = {9, 4, 8, 6, 1, 3};

        for (int i = 1; i < array.length; i++) {
            int temp = array[i];
            for (int j = i-1; j >= 0; j--) {
                if(array[j] > temp){
                    array[j+1] = array[j];
                    if (j == 0){
                        array[0] = temp;
                    }
                }else {
                    array[j+1] = temp;
                    break;
                }
            }
        }
        for (int i : array) {
            System.out.println(i);
        }

    }
}

选择排序

public class Selectsort {//选择排序

    public static void main(String[] args) {
        int[] array = {5,2,9,8,4,1};

        int temp = 0;
        for (int j = 0; j < array.length-1; j++) {
            int min = j;
            for (int i = j+1; i < array.length; i++) {
                if (array[i] < array[min]){
                    min = i;
                }
            }
            temp = array[j];
            array[j] = array[min];
            array[min] = temp;
        }

        for (int i : array) {
            System.out.println(i);
        }
    }
}

稀疏数组

public static int[][] sparseArray(int[][] array){
    int num = 0;
    int[][] sparsearray = new int[num+1][3];
    int count = 0;

    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            if (array[i][j]!=0){
                num++;
            }
        }
    }

    sparsearray[0][0] = array.length;
    sparsearray[0][1] = array[0].length;
    sparsearray[0][2] = num;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            if (array[i][j]!=0){
                count++;
                sparsearray[count][0]=i;
                sparsearray[count][1]=j;
                sparsearray[count][2]=array[i][j];
            }
        }
    }
    return sparsearray;
}

构造器

在这里插入图片描述

public class Person {
    //一个类即使什么也不写，也会存在一个方法（构造器）

    String name;

    //显示定义的构造器
    
    //1.使用new操作，本质上是在调用构造器
    //2.用来初始化值
    public Person(){

    }
    //有参构造：一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        this.name = name;
    }
}
alt+insect 快速创建构造器

super详解

在这里插入图片描述

方法重写

在这里插入图片描述

多态

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class Person {
    public static void main(String[] args) {
        try {
            new Person().test(1,0);
        }catch(ArithmeticException e){
            e.printStackTrace();
        }

    }
    //假设这个方法中，处理不了这个异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if (b == 0){
            throw new ArithmeticException();//主动抛出的异常，在方法中用
        }
    }
}

随机值

math.random()//生成0~1的浮点数

包装类

public class PackageClass {
    public static void main(String[] args) {
        
        int i = 0;
        // 自动装箱（基础数据类型转化为引用数据类型）
        Integer num = i;
        // 自动拆箱（引用数据类型转化为基础数据类型）
        int j = num;
        int max = Integer.max(3,6);
        System.out.println(max); //6
        
        // 查看int最大、最小值
        System.out.println(Integer.MAX_VALUE); //2147483647
        System.out.println(Integer.MIN_VALUE); //-2147483648

        // 将字符串转化为int(静态方法)
        int i1 = Integer.parseInt("221"); //221
        System.out.println(i1);
    }
}
8 种数据类型就有8种包装类，包装类（如Integer）Integer为引用数据类型

超级数组

package com.ma;

/**
 * @author mf
 */
public class SuperArray {

    private int[] array;
    private int currentIndex = 0;

    public SuperArray() {
        this(10);
    }
    public SuperArray(int size) {
        array = new int[size];
    }

    /**
     * 排序
     */
    public void sort(){
        for (int i = 0; i < currentIndex - 1; i++) {
            for (int j = 0; j < currentIndex -1 -i; j++) {
                if (array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }

    /**
     * 添加数据
     * @param newData
     */
    public SuperArray addData(int newData){
        currentIndex ++ ;
        // 游标加完之后越界
        if (currentIndex >= array.length){
            int[] newArray= new int[array.length*2];
            for (int i = 0; i < currentIndex; i++) {
                newArray[i] = array[i];
            }
            array = newArray;
        }
        array[currentIndex-1] = newData;
        return this;
    }

    /**
     * 删除指定位置的元素
     * @param index
     */
    public void deleteData(int index){
        if (index < 0 || index > currentIndex ){
            System.out.println("输入的下标不合法!");
            return;
        }
        for (int i = index - 1; i < currentIndex; i++) {
            array[i] = array[i+1];
        }
        currentIndex-- ;
    }

    /**
     * 打印数组
     */
    public void print(){
        System.out.print("输出的数组为:");
        for (int i = 0; i < currentIndex; i++) {
            System.out.print(array[i] + "   ");
        }
        System.out.println();
    }

    /**
     * 将数组变为字符串格式输出
     */
    public String toStr(){
        String res = "";
        for (int i = 0; i < currentIndex; i++) {
            if (i == currentIndex){// 不在最后加，
                res += array[i];
            }else{
                res += array[i]+",";
            }
        }
        return res;
    }

}

值传递与引用传递

public class Test {
    public static void main(String[] args) {
        // 引用传递(传的是地址，该地址的数组经过方法sort，已经变为排序后的数组)
        int[] nums = {1,2,5,6,4};
        Test t = new Test();
        t.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }                                      //1，2，4，5，6
        System.out.println();
        //值传递(传的是值)
        int i = 4;
        int j = 5;
        t.puls(i,j);
        System.out.println(i);                 //4


    }
    public void sort(int[] array){
        for (int i = 0; i < array.length -1; i++) {
            for (int j = 0; j < array.length -1 -i; j++) {
                if (array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }

    public void puls(int i,int j){
        i = i + j;
    }
}

权限修饰符

private 支持同类

friendly 支持同类，同包，同文件

protected 支持同类，同包，同文件，父子

public 全部支持

继承

子类继承父类，创建子类时自动调用父类的无参构造方法

父类无参构造
package com.ma.baseclass;

/**
 * @author DELL
 */
public class Father {
    private String hobby;


    public Father() {
        System.out.println("调用父类的无参构造方法");
    }

    public void somke(){
        System.out.println("抽中华！");
    }
}

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Son extends Father{

    @Override // 注解：方法重写
    public void somke() {
//        super.somke();
        System.out.println("抽红塔山");
    }
}

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Test {
    public static void main(String[] args) {
        Son son = new Son();//调用父类的无参构造方法
    }
}
父类有参构造
package com.ma.baseclass;

/**
 * @author DELL
 */
public class Father {
    private String hobby;


    public Father(String hobby) {
        this.hobby = hobby;
        System.out.println("调用父类的有参构造方法");
    }

    public void somke(){
        System.out.println("抽中华！");
    }
}

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Son extends Father{
    public Son() {
        super("烫头"); // super 必须放在首行，super和this不能同时调用构造方法
        System.out.println("调用子类的有参构造方法");
    }

    @Override // 注解：方法重写
    public void somke() {
//        super.somke();
        System.out.println("抽红塔山");
    }
}

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        //调用父类的有参构造方法
        //调用子类的有参构造方法

    }
}

java类加载的顺序

父类的静态字段——>父类静态代码块——>子类静态字段——>子类静态代码块——>

父类成员变量（非静态字段）——>父类非静态代码块——>父类构造器——>子类成员变量——>子类非静态代码块——>子类构造器

静态代码块,静态属性
public static String NAME = "老王"; // 大写变量
static {//类加载的时候就会调用
    //类加载的时机，第一次主动使用这个类（new，调用类方法等），把他加载到内存
}
{//非静态代码块

}

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Father {


    /**
     * 父类的静态属性
     */
    public static String NAME = "老王";

    // 父类的静态代码块
    static {
        System.out.println("父类静态的属性:" + NAME);
        System.out.println("父类的静态代码块");
    }

    /**
     * 父类的非静态属性
     */
    private String hobby = "学习";

    // 父类的非静态代码块
    {
        System.out.println("父类非静态的属性:" + hobby);
        System.out.println("父类的非静态代码块");
    }

    public Father(String hobby) {
        this.hobby = hobby;
        System.out.println("父类构造方法");
    }

    public void somke(){
        System.out.println("抽中华！");
    }
    static {

    }
}

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Son extends Father{

    /**
     * 子类的静态属性
     */
    public static String NAME = "儿子";

    // 父类的静态代码块
    static {
        System.out.println("子类静态的属性:" + NAME);
        System.out.println("子类的静态代码块");
    }

    /**
     * 子类的非静态属性
     */
    private String hobby = "健身";

    // 父类的非静态代码块
    {
        System.out.println("子类非静态的属性:" + hobby);
        System.out.println("子类的非静态代码块");
    }

    public Son() {
        super("烫头");
        System.out.println("子类构造方法");
    }

    @Override // 注解：方法重写
    public void somke() {
//        super.somke();
        System.out.println("抽红塔山");
    }
}

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Test {
    public static void main(String[] args) {
        Son s = new Son();
    }
}

返回结果：

父类静态的属性:老王
父类的静态代码块
子类静态的属性:儿子
子类的静态代码块
父类非静态的属性:学习
父类的非静态代码块
父类构造方法
子类非静态的属性:健身
子类的非静态代码块
子类构造方法

概括：加载父类–>加载子类–>构造父类–>构造父类

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Test {
    public static void main(String[] args) {
        Father father1 = new Father("抽烟");
        Father father2 = new Father("抽烟");
      
        int i = 2;
        int j = 2;
        System.out.println(i == j);// true

        String s = "a";
        String s1 = "a";
        String s2 = new String("a
        String s3 = new String("a");
        
        System.out.println(father1 == father2);// false
        System.out.println(father1.equals(father2));// false(Father此时未重写equals方法)
        System.out.println(i == j);// true
        System.out.println(s2.equals(s3));// true(String 重写了equals方法)
        System.out.println(s == s1);// true
        System.out.println(s == s2);// false
        System.out.println(s2 == s3);// false
    }
}
重写equals方法(重写equals方法必须要重写hashcode方法)，强制转换
@Override
public boolean equals(Object obj) {
    Father father;
    if (obj instanceof Father){
        father = (Father) obj;//强制转换(父类转子类)    自动转换(子类转父类)
        if (this.getHobby().equals(father.getHobby())){
            return true;
        }
    }
    return false;
}

对象instanceof类

package com.ma.baseclass;

/**
 * @author DELL
 */
public class Test {
    public static void main(String[] args) {
        Father father1 = new Father("抽烟");
        Father father2 = new Father("抽烟");
        Son son = new Son();
        Object obj = new Object();
        System.out.println(father1 instanceof Father);//true
        System.out.println(son instanceof Father);//true
        System.out.println(father2 instanceof Son);//false
        System.out.println(obj instanceof Father);//false
    }
}

强制转换(父类转子类)向上转型【注】父类不能调用儿子的方法，故需要迁至转换成儿子类型。

自动转换(子类转父类)向下转型【注】子类可以调用父类的方法，故可自动转换

Integer.toHexString()转化为十进制方法，静态方法
package com.ma.baseclass;

/**
 * @author DELL
 */
public class Test {
    public static void main(String[] args) {
        User user = new User();
        System.out.println(user.hashCode());//1435804085  (返回十进制的哈希码)
        System.out.println(user.toString());//com.ma.baseclass.User@5594a1b5
        System.out.println(user);// 打印一个类默认调用toSring()方法
        System.out.println("aaa".hashCode());//96321  (重写了hashCode()方法)
        System.out.println("aaa".toString());// aaa (重写了toString()方法)
    }
}

多态

  • 继承

  • 重写

  • 父类引用指向子类对象(可以动态的调用子类重写的方法) 父类 父类对象 = new 子类

    package com.ma.baseclass;

/**
 * @author DELL
 */
public class Test {
    public static void main(String[] args) {
        Father f = new Son();
        f.somke();//执行重写的父类方法
    }
}

抽象类

  • 父类为抽象类，仅仅定义需要子类重写的方法，不实现
  • 子类必须实现(重写)父类的抽象方法
  • 快捷键：alt+enter在这里插入图片描述
package com.ma.animial; 

public abstract class Animial {
    /**
     * 抽象方法
     */
    public abstract void breathe();
    
    public abstract void eat();
}

package com.ma.animial;

/**
 * @author DELL
 */
public class Dog extends Animial{

    @Override
    public void breathe() {
        System.out.println("狗呼吸");
    }

    @Override
    public void eat() {
        System.out.println("实现父类抽象类中的抽象方法");
    }
}

package com.ma.animial;

/**
 * @author DELL
 */
public class Cat extends Animial{

    @Override
    public void breathe() {
        System.out.println("猫呼吸");
    }

    @Override
    public void eat() {
        System.out.println("111");
    }
}

接口

如果一个抽象类的所有方法均为抽象方法，那么这个类就是接口

接口的方法默认为public

package com.ma.animial;

public interface Animial {
    /**
     * 呼吸
     */
    void breathe();
    /**
     * 吃
     */
    void eat();
}

package com.ma.animial;

/**
 * @author DELL
 */
public class Dog implements Animial{

    @Override
    public void breathe() {
        System.out.println("狗呼吸");
    }

    @Override
    public void eat() {
        System.out.println("实现父类抽象类中的抽象方法");
    }
}

超级链表（多态，接口）

package com.ma;

/**
 * @author DELL
 */
public interface Super {
    void addData(Integer data);
    void deleteData(int index);
    void updateData(int index,Integer data);
    void print();
    int size();
}

package com.ma;

/**
 * @author mf
 */
public class SuperArray implements Super{

    private int[] array;
    private int currentIndex = 0;

    public SuperArray() {
        this(10);
    }
    public SuperArray(int size) {
        array = new int[size];
    }

    /**
     * 排序
     */
    public void sort(){
        for (int i = 0; i < currentIndex - 1; i++) {
            for (int j = 0; j < currentIndex -1 -i; j++) {
                if (array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }

    /**
     * 添加数据
     * @param newData
     */
    @Override
    public void addData(Integer newData){
        currentIndex ++ ;
        // 游标加完之后越界
        if (currentIndex >= array.length){
            int[] newArray= new int[array.length*2];
            for (int i = 0; i < currentIndex; i++) {
                newArray[i] = array[i];
            }
            array = newArray;
        }
        array[currentIndex-1] = newData;
    }

    /**
     * 删除指定位置的元素
     * @param index
     */
    @Override
    public void deleteData(int index){
        if (index < 0 || index > currentIndex ){
            System.out.println("输入的下标不合法!");
            return;
        }
        for (int i = index - 1; i < currentIndex; i++) {
            array[i] = array[i+1];
        }
        currentIndex-- ;
    }

    /**
     * 修改指定位置数据
     * @param index
     * @param data
     */
    @Override
    public void updateData(int index,Integer data){
        array[index-1] = data;
    }

    /**
     * 打印数组
     */
    @Override
    public void print(){
        System.out.print("输出的数组为:");
        for (int i = 0; i < currentIndex; i++) {
            System.out.print(array[i] + "   ");
        }
        System.out.println();
    }

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

    /**
     * 将数组变为字符串格式输出
     */
    public String toStr(){
        String res = "";
        for (int i = 0; i < currentIndex; i++) {
            if (i == currentIndex-1){
                res += array[i];
            }else{
                res += array[i]+",";
            }
        }
        return res;
    }

}

package com.ma;

import java.util.TimerTask;

/**
 * @author DELL
 */
public class SuperLink implements Super{
    private Node head;
    private int size;

    /**
     * 添加数据
     * @param data
     */
    @Override
    public void addData(Integer data){
//        /**
//         * 头插法
//         */
//        // 1.将加入的node变为新头部
//        Node newhead = new Node(data,null);
//        // 2.将加入的node指向旧头部
//        newhead.setNext(head);
//        // 3.将新的头部变为头部
//        head = newhead;
        /**
         * 尾插法
         */
        Node tail = head;
        Node newtail = new Node(data,null);
        if (head == null){
            head = newtail;
            return;
        }

        while (true){
            if (tail.getNext() == null) {
                break;
            }
            tail = tail.getNext();
        }
        tail.setNext(newtail);
        size++;
    }

    /**
     * 删除指定位置的数据
     * @param index
     */
    @Override
    public void deleteData(int index){
        if (index == 1){
            head = getNode(index).getNext();
        } else {
          Node node = getNode(index - 1);
          node.setNext(getNode(index).getNext());
        }
        size--;
    }

    /**
     * 得到指定位置的数据
     * @param index
     * @return
     */
    public Integer get(int index){
        return getNode(index).getData();
    }

    /**
     * 得到指定位置的节点
     * @param index
     * @return node
     */
    private Node getNode(int index){
        Node node = head;
        for (int i = 1; i < index; i++) {
            node = node.getNext();
        }
        return node;
    }

    /**
     * 修改指定位置数据
     * @param index
     * @param data
     */
    @Override
    public void updateData(int index,Integer data){
        Node node = getNode(index);
        node.setData(data);
     }

    /**
     * 打印链表
     */
    @Override
    public void print(){
        System.out.print("输出的链表数据为： ");
        Node node = head;
        while (true){
            if (node == null){
                break;
            }
            System.out.print(node.getData() + " ");
            node = node.getNext();
        }
        System.out.println();
    }

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

泛型

package com.ma;

/**
 * @author DELL
 */
public interface Super <T>{
    void addData(T data);
    void deleteData(int index);
    void updateData(int index,T data);
    void print();
    int size();
}

package com.ma;

/**
 * @author DELL
 */
public class Node <T>{
    /**
     * 传入的数据
     */
    private T data;
    /**
     * 节点
     */
    private Node next;

    /**
     * 无参构造方法
     */
    public Node(){

    }

    /**
     * 有参构造
     * @param data
     * @param next
     */
    public Node(T data, Node next) {
        this.data = data;
        this.next = next;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", node=" + next +
                '}';
    }
}

package com.ma;

/**
 * @author mf
 */
public class SuperArray<T> implements Super<T>{

    private Object[] array;
    private int currentIndex = 0;

    public SuperArray() {
        this(10);
    }
    public SuperArray(int size) {
        array = new Object[size];
    }

//    /**
//     * 排序
//     */
//    public void sort(){
//        for (int i = 0; i < currentIndex - 1; i++) {
//            for (int j = 0; j < currentIndex -1 -i; j++) {
//                if (array[j] > array[j+1]){
//                    int temp = array[j];
//                    array[j] = array[j+1];
//                    array[j+1] = temp;
//                }
//            }
//        }
//    }

    /**
     * 添加数据
     * @param newData
     */
    @Override
    public void addData(T newData){
        currentIndex ++ ;
        // 游标加完之后越界
        if (currentIndex >= array.length){
            Object[] newArray= new Object[array.length*2];
            for (int i = 0; i < currentIndex; i++) {
                newArray[i] = array[i];
            }
            array = newArray;
        }
        array[currentIndex-1] = newData;
    }

    /**
     * 删除指定位置的元素
     * @param index
     */
    @Override
    public void deleteData(int index){
        if (index < 0 || index > currentIndex ){
            System.out.println("输入的下标不合法!");
            return;
        }
        for (int i = index - 1; i < currentIndex; i++) {
            array[i] = array[i+1];
        }
        currentIndex-- ;
    }

    /**
     * 修改指定位置数据
     * @param index
     * @param data
     */
    @Override
    public void updateData(int index,T data){
        array[index-1] = data;
    }

    /**
     * 打印数组
     */
    @Override
    public void print(){
        System.out.print("输出的数组为:");
        for (int i = 0; i < currentIndex; i++) {
            System.out.print(array[i] + "   ");
        }
        System.out.println();
    }

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

    /**
     * 将数组变为字符串格式输出
     */
    public String toStr(){
        String res = "";
        for (int i = 0; i < currentIndex; i++) {
            if (i == currentIndex-1){
                res += array[i];
            }else{
                res += array[i]+",";
            }
        }
        return res;
    }

}

package com.ma;

import java.util.TimerTask;

/**
 * @author DELL
 */
public class SuperLink<T> implements Super<T>{
    private Node head;
    private int size;

    /**
     * 添加数据
     * @param data
     */
    @Override
    public void addData(T data){
//        /**
//         * 头插法
//         */
//        // 1.将加入的node变为新头部
//        Node newhead = new Node(data,null);
//        // 2.将加入的node指向旧头部
//        newhead.setNext(head);
//        // 3.将新的头部变为头部
//        head = newhead;
        /**
         * 尾插法
         */
        Node tail = head;
        Node newtail = new Node(data,null);
        if (head == null){
            head = newtail;
            return;
        }

        while (true){
            if (tail.getNext() == null) {
                break;
            }
            tail = tail.getNext();
        }
        tail.setNext(newtail);
        size++;
    }

    /**
     * 删除指定位置的数据
     * @param index
     */
    @Override
    public void deleteData(int index){
        if (index == 1){
            head = getNode(index).getNext();
        } else {
          Node node = getNode(index - 1);
          node.setNext(getNode(index).getNext());
        }
        size--;
    }

    /**
     * 得到指定位置的数据
     * @param index
     * @return
     */
    public T get(int index){
        return (T) (getNode(index).getData());
    }

    /**
     * 得到指定位置的节点
     * @param index
     * @return node
     */
    private Node getNode(int index){
        Node node = head;
        for (int i = 1; i < index; i++) {
            node = node.getNext();
        }
        return node;
    }

    /**
     * 修改指定位置数据
     * @param index
     * @param data
     */
    @Override
    public void updateData(int index,T data){
        Node node = getNode(index);
        node.setData(data);
     }

    /**
     * 打印链表
     */
    @Override
    public void print(){
        System.out.print("输出的链表数据为： ");
        Node node = head;
        while (true){
            if (node == null){
                break;
            }
            System.out.print(node.getData() + " ");
            node = node.getNext();
        }
        System.out.println();
    }

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

生成jar包

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

导入jar包

在这里插入图片描述

栈和队列

package com.ma;

/**
 * @author DELL
 */
public class Stack<T> {
    private SuperArray<T> superArray = new SuperArray<>();
    /**
     * 入栈
     */
    public void put(T data){
        superArray.addData(data);
    }
    public T pop(){
        System.out.print("弹出了：");
        if (superArray.size() >= 1){
            T temp = superArray.get(superArray.size()-1);
            superArray.deleteData(superArray.size());
            return temp;
        }
        return null;
    }
}

package com.ma;

/**
 * @author DELL
 */
public class Queue <T>{
    private SuperArray<T> superArray = new SuperArray<>();
    /**
     * 入队列
     */
    public void put(T data){
        superArray.addData(data);
    }
    public T take(){
        System.out.print("出队：");
        if (superArray.size() >= 1){
            T temp = superArray.get(0);
            superArray.deleteData(1);
            return temp;
        }
        return null;
    }
}

被final修饰的类不能被继承

被final修饰的变量不能被更改

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值