Java入门四步走

1. 简单的入门语法：

1.1 数据类型：

基本数据类型：
整数类型 —— byte、short、int、long,
浮点类型 —— float、double
字符类型 —— char
布尔类型 —— boolean

引用数据类型：
接口（interface）、数组（[ ]）、类（class）。

1.2 循环怎么写：

1) 顺序控制

2) 分支控制：
1) 单分支 if； 2) 双分支 if-else； 3) 多分支 if-elseif-....-else；4）switch 分支结构

3) 循环控制：for循环；while循环；do..while循环

1.3 数组怎么定义：

先声明数组：语法: 数据类型数组名[]; 也可以数据类型[] 数组名; int a [ ]; 或者 int[ ] a;

创建数组： 语法: 数组名=new 数据类型[大小]; a = new int[10];

1.4 函数是怎么写的

修饰符返回值类型函数名称（参数类型参数1，参数类型参数2， . . . ）{
                函数执行代码；
                return 返回值；
        }

public static int addFunc (int a,int b) {
return a+b;
}

返回值类型：函数运行后的结果类型
参数类型：是形式参数的数据类型
形式参数：是一个变量，由于存储调用函数时传递给函数的实际参数
实际参数：传递给函数的具体值
return:用于结束函数
返回值：函数运算后的结果值，该值会返回给该函数的调用者
注意：当函数没有返回值类型是用void来表示
如果返回值类型是void，name函数中的return语句可以省略不写

2.用这个编程语言实现基础的数据结构：

2.1 顺序表:

顺序表的实现：

public class SeqList{
 	private int length;//表长
    private int[] datas;//数据
}

顺序表的创建和初始化：

	/**
     * 创建空的顺序表
     */
    public SeqList() {
    }

    /**
     * 创建一个指定容量的顺序表
     *
     * @param capacity
     */
    public SeqList(int capacity) {
        length = 0;
        datas = new int[capacity];
    }

    /**
     * 构造指定容量和指定数组元素的顺序表
     * @param capacity
     * @param array
     */
    public SeqList(int capacity, int[] array) {
        if (capacity < array.length) {
            throw new IndexOutOfBoundsException();
        } else {
            length = 0;
            datas = new int[capacity];
            for (int i = 0; i < array.length; i++) {
                datas[i] = array[i];
                length++;
            }
        }
    }

    /**
     * 初始化表的最大容量
     *
     * @param capacity
     */
    public void create(int capacity) {
        if (datas != null) {
            throw new RuntimeException();
        } else {
            length = 0;
            datas = new int[capacity];
        }

    }

获取指定下标的元素：

   /**
     * 获取指定下标的元素
     *
     * @param index
     * @return
     */
    public int get(int index) {
        if (index <= length && index >= 0) {
            return datas[index];
        } else {
            throw new IndexOutOfBoundsException();
        }
    }

指定位置插入元素：

  /**
     * 指定位置插入元素
     *
     * @param index
     * @param element
     */
    public void insert(int index, int element) {
        if (index >= length || index < 0) {
            throw new IndexOutOfBoundsException();
        } else {
            if (length + 1 <= datas.length) {
                for (int i = length; i > index; i--) {
                    datas[i] = datas[i - 1];
                }
                datas[index] = element;
                length++;
            } else {
                System.out.println("表已满，无法插入");
            }
        }
    }

删除指定下标元素：

    /**
     * 删除指定下标元素
     *
     * @param index
     */
    public void delete(int index) {
        if (index < 0 || index >= length) {
            throw new IndexOutOfBoundsException();
        } else {
            for (int i = index; i < length - 1; i++) {
                datas[i] = datas[i + 1];
            }
            length--;
        }
    }

其他操作：

    /**
     * 在表尾添加元素
     *
     * @param element
     */
    public void add(int element) {
        if (datas.length <= length) {
            System.out.println("表已满，无法添加");
        } else {
            datas[length] = element;
            length++;
        }
    }


     /**
     * 判断表是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        if (datas == null || (datas.length == 0 && length == 0)) {
            return true;
        } else {
            return false;
        }
    }


    /**
     * 清空表
     */
    public void clear() {
        datas = null;
        length = 0;
    }

    /**
     * 获取表长
     *
     * @return
     */
    public int length() {
        return length;
    }

    /**
     * 获取表的最大容量
     *
     * @return
     */
    public int getMaxSize() {
        return datas.length;
    }

输出顺序表的元素：

     /**
     * 重写toString(),输出表中元素
     *
     * @return
     */
    @Override
    public String toString() {
        if (length <= 0) {
            return null;
        } else {
            StringBuilder sb = new StringBuilder();
            sb.append("[");
            for (int i = 0; i < length; i++) {
                if (i == length - 1) {
                    sb.append(datas[i]);
                } else {
                    sb.append(datas[i] + ",");
                }
            }
            return sb.append("]").toString();
        }
    }

代码测试:

public class SeqListDemo {
    public static void main(String[] args) {
        int[] array=new int[]{2,4,8,3,6,1,4};
        System.out.println("//创建最大容量为10，指定数组元素的顺序表");
        SeqList seqList=new SeqList(10,array);//创建最大容量为10，指定数组元素的顺序表
        System.out.print("获取顺序表最大容量：");
        int maxSize = seqList.getMaxSize();
        System.out.println(maxSize);
        System.out.print("获取顺序表元素：");
        System.out.println(seqList.toString());
        System.out.print("获取顺序表长度：");
        System.out.println(seqList.length());
        System.out.print("添加元素0：");
        seqList.add(0);
        System.out.println(seqList.toString());
        System.out.print("在第1个数前插入元素10：");
        seqList.insert(0,10);
        System.out.println(seqList.toString());
        System.out.print("获取顺序表长度：");
        System.out.println(seqList.length());
        System.out.print("获取顺序表第3个数字：");
        System.out.println(seqList.get(2));
        System.out.println("清空顺序表");
        seqList.clear();
        System.out.print("顺序表元素：");
        System.out.println(seqList.toString());
    }
}

创建最大容量为10，指定数组元素的顺序表
获取顺序表最大容量:10
获取顺序表元素:[2,4,8,3,6,1,4]
获取顺序表长度:7
添加元素0:[2,4,8,3,6,1,4,0]
在第1个数前插入元素10:[10,2,4,8,3,6,1,4,0]
获取顺序表长度:9
获取顺序表第3个数字:4
清空顺序表元素:null

2.2 串:

Java String类：

创建字符串

创建一个String对象，并初始化一个值。
String类是不可改变的，一旦创建了一个String对象，它的值就不能改变了。
如果想对字符串做修改，需要使用StringBuffer&StringBuilder类。

//直接创建方式
String str1 = "abc";
//提供一个 字符数组 参数来初始化字符串
char[] strarray = {'a','b','c'};
String str2 = new String(strarray);

char 为字符类型，String为字符串类型
String 字符串是用" "来包含串的, char是用’ '来包含单字符的
String 内部用来存储的结果是一个char字符数组

字符串长度获取

int length()方法：返回字符串对象包含的字符数。

int len = str.length();

连接字符串

String concat(String str)：连接两个字符串的方法
或者直接用‘+’操作符来连接

//String对象的连接
str1.concat(str2);

"两个字符串连接结果："+str1+str2;

字符串查找
int indexOf(String s)：字符串s在指定字符串中首次出现的索引位置，如果没有检索到字符串s，该方法返回-1
int lastIndexOf(String s)：字符串s在指定字符串中最后一次出现的索引位置，如果没有检索到字符串s，该方法返回-1；如果s是空字符串，则返回的结果与length方法的返回结果相同，即返回整个字符串的长度。

int idx = str.indexOf("a");//字符a在str中首次出现的位置
int idx = str.lastIndexOf("a");

获取指定位置的字符串

char charAt(int index)方法：返回指定索引出的字符

String str = "abcde";
char thischar = str.charAt(3);//索引为3的thischar是"d"

获取子字符串
String substring()方法：实现截取字符串，利用字符串的下标索引来截取(字符串的下标是从0开始的，在字符串中空格占用一个索引位置)
1. substring(int beginIndex)：截取从指定索引位置开始到字符串结尾的子串
2. substring(int beginIndex, int endIndex)：从beginIndex开始，到endIndex结束(不包括endIndex)

String str = "abcde";
String substr1 = str.substring(2);//substr1为"cde"
String substr2 = str.substring(2,4);//substr2为"cd"

去除字符串首尾的空格()

String trim()方法

String str = " ab cde ";
String str1 = str.trim();//str1为"ab cde"

字符串替换
1.String replace(char oldChar, char newChar)：将指定的字符/字符串oldchar全部替换成新的字符/字符串newChar
2.String replaceAll(String regex, String replacement)：使用给定的参数 replacement替换字符串所有匹配给定的正则表达式的子字符串
3. String replaceFirst(String regex, String replacement)：使用给定replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
regex是正则表达式，替换成功返回替换的字符串，替换失败返回原字符串

String str = "abcde";
String newstr = str.replace("a","A");//newstr为"Abcde"

判断字符串的开始与结尾
boolean startsWith()
1.boolean startsWith(String prefix)：判断此字符串是否以指定的后缀prefix开始
2.boolean startsWith(String prefix, int beginidx)：判断此字符串中从beginidx开始的子串是否以指定的后缀prefix开始
3. boolean endsWith(String suffix)：判断此字符串是否以指定的后缀suffix结束

String str = "abcde";
boolean res = str.startsWith("ab");//res为true
boolean res = str.StartsWith("bc",1);//res为true
boolean res = str.endsWith("de");//res为true

判断字符串是否相等
1. boolean equals(Object anObject)：将此字符串与指定的对象比较，区分大小写
2. boolean equalsIgnoreCase(String anotherString)：将此 String 与另一个 String 比较，不考虑大小写

String str1 = "abcde";
String str2 = str1;//字符串str1和str2都是一个字符串对象
String str3 = "ABCDE";
boolean isEqualed = str1.equals(str2);//返回true
boolean isEqualed = str1.equals(str3);//返回false
boolean isEqualed = str1.equlasIgnoreCase(str3);//返回true

比较两个字符串
1. int compareTo(Object o)：把这个字符串和另一个对象比较。
2. int compareTo(String anotherString)：按字典顺序比较两个字符串。
比较对应字符的大小(ASCII码顺序)，如果参数字符串等于此字符串，则返回值 0；如果此字符串小于字符串参数，则返回一个小于 0 的值；如果此字符串大于字符串参数，则返回一个大于 0 的值。

String str1 = "abcde";
String str2 = "abcde123";
String str3 = str1;
int res = str1.compareTo(str2);//res = -3
int res = str1.compareTo(str3);//res = 0
int res = str2.compareTo(str1);//res = 3

把字符串转换为相应的数值

String转int型：

//第一种
int i = Integer.parseInt(String str)
//第二种
int i = Integer.valueOf(s).intValue();

String转long型：

long l = Long.parseLong(String str);

String转double型：

double d = Double.valueOf(String str).doubleValue();//doubleValue()不要也可
double d = Double.parseDouble(str);

int转string型：

//第一种
String s = String.valueOf(i)；
//第二种
String s = Integer.toString(i);
//第三种
String s = "" + i;

字符大小写转换

String toLowerCase()：将字符串中的所有字符从大写字母改写为小写字母
String toUpperCase()：将字符串中的所有字符从小写字母改写为大写字母

String str1 = "abcde";
String str2 = str1.toUpperCase();//str2 = "ABCDE";
String str3 = str2.toLowerCase();//str3 = "abcde";

字符串分割
String[] split()：根据匹配给定的正则表达式来拆分字符串，将分割后的结果存入字符数组中。

1. String[] split(String regex)：regex为正则表达式分隔符, . 、 $、 | 和 * 等转义字符，必须得加 \\；多个分隔符，可以用 | 作为连字符。
2. String[] split(String regex, int limit)：limit为分割份数

String str = "Hello World A.B.C"
String[] res = str.split(" ");//res = {"Hello","World","A.B.C"}
String[] res = str.split(" ",2);//res = {"Hello","World A.B.C"}
String[] res = str.split("\\.");//res = {"Hello World A","B","C"}

String str = "A=1 and B=2 or C=3"
String[] res = str.split("and|or");//res = {"A=1 "," B=2 "," C=3"}

字符数组与字符串的转换

public String(char[] value) ：通过char[]数组来创建字符串
char[] toCharArray()：将此字符串转换为一个新的字符数组。

String str = "abcde";
char mychar[] = str.toCharArray();//char[0] = 'a'; char[1] = 'b'...

字符串与byte数组的转换
byte[] getBytes()
1. byte[] getBytes()：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
2. byte[] getBytes(String charsetName)：使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

byte[] Str2 = Str1.getBytes();

StringBuffer&StringBuilder类
与String类最大的不同在于这两个类可以对字符串进行修改。
StringBuilder相较StringBuffer来说速度较快，多数情况下使用StringBuilder，但是StringBuilder的方法不是线性安全的（不能同步访问），所以在应用程序要求线程安全的情况下，必须使用StringBuffer。

创建StringBuffer字符串

StringBuffer str = new StringBuffer("");

添加字符(最常用方法)

public StringBuffer append(String s)：将指定的字符串追加到字符序列中

str.append("abc");//此时str为“abc”

删除字符串中的指定字符

public delete(int start,int end)：移除此序列中的子字符串的内容
public deleteCharAt(int i)：删除指定位置的字符

str.delete(0,1);//此时str为“c”
str.deleteCharAt(str.length()-1);//删除最后一个字符

翻转字符串

public StringBuffer reverse()

str.reverse();

替换字符串中内容
replace(int start,int end,String str)：用String类型的字符串str替换此字符串的子字符串中的内容

String s = "1";
str.replace(1,1,s);//此时str为"a1c"

插入字符
public insert(int offset, int i)：将int参数形式的字符串表示形式插入此序列中

str.insert(1,2);

字符串长度
int length()：返回长度（字符数）
void setLength(int new Length)：设置字符序列的长度

str.length();
str.setLength(4);

当前容量
int capacity()：获取当前容量
void ensureCapacity(int minimumCapacity)：确保容量小于指定的最小值

str.capacity();

将其转变为String
String toString()

str.toString();//将StringBuffer类型的序列转变为String类型的字符串

设置指定索引处的字符
void setCharAt(int index，char ch)：将给定索引处的字符设置为ch
其余方法和String类型的方法大致相同。

2.3 链表

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。

一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。

Java LinkedList（链表）类似于 ArrayList，是一种常用的数据容器。
与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。

以下情况使用 ArrayList :

频繁访问列表中的某一个元素。
只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

你需要通过循环迭代来访问列表中的某些元素。
需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

2.4 栈

栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
堆栈只定义了默认构造函数，用来创建一个空栈。堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。

Stack()

除了由Vector定义的所有方法，自己也定义了一些方法：

实例：

import java.util.*;
 
public class StackDemo {
 
    static void showpush(Stack<Integer> st, int a) {
        st.push(new Integer(a));
        System.out.println("push(" + a + ")");
        System.out.println("stack: " + st);
    }
 
    static void showpop(Stack<Integer> st) {
        System.out.print("pop -> ");
        Integer a = (Integer) st.pop();
        System.out.println(a);
        System.out.println("stack: " + st);
    }
 
    public static void main(String args[]) {
        Stack<Integer> st = new Stack<Integer>();
        System.out.println("stack: " + st);
        showpush(st, 42);
        showpush(st, 66);
        showpush(st, 99);
        showpop(st);
        showpop(st);
        showpop(st);
        try {
            showpop(st);
        } catch (EmptyStackException e) {
            System.out.println("empty stack");
        }
    }
}

以上实例编译运行结果如下：

stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

2.5 队列

队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。
LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。

import java.util.LinkedList;
import java.util.Queue;
 
public class Main {
    public static void main(String[] args) {
        //add()和remove()方法在失败的时候会抛出异常(不推荐)
        Queue<String> queue = new LinkedList<String>();
        //添加元素
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
    }
}

a
b
c
d
e
===
poll=a
b
c
d
e
===
element=b
b
c
d
e
===
peek=b
b
c
d
e

2.6 树

在计算机科学中，树（英语：tree）是一种抽象数据类型（ADT）或是实现这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>0）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

每个节点都只有有限个子节点或无子节点；
没有父节点的节点称为根节点；
每一个非根节点有且只有一个父节点；
除了根节点外，每个子节点可以分为多个不相交的子树；
树里面没有环路(cycle)

为什么需要树？
因为它结合了另外两种数据结构的优点：一种是有序数组，另一种是链表。在树中查找数据项的速度和在有序数组中查找一样快，并且插入数据项和删除数据项的速度也和链表一样。

// 节点类
class TreeNode {
    private int value;
    private TreeNode left;
    private TreeNode right;

    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }

    // 获取节点值
    public int getValue() {
        return value;
    }

    // 设置左子节点
    public void setLeft(TreeNode left) {
        this.left = left;
    }

    // 获取左子节点
    public TreeNode getLeft() {
        return left;
    }

    // 设置右子节点
    public void setRight(TreeNode right) {
        this.right = right;
    }

    // 获取右子节点
    public TreeNode getRight() {
        return right;
    }
}

// 树类
class Tree {
    private TreeNode root;

    public Tree() {
        this.root = null;
    }

    // 插入节点
    public void insert(int value) {
        root = insertNode(root, value);
    }

    private TreeNode insertNode(TreeNode node, int value) {
        if (node == null) {
            return new TreeNode(value);
        }

        if (value < node.getValue()) {
            node.setLeft(insertNode(node.getLeft(), value));
        } else if (value > node.getValue()) {
            node.setRight(insertNode(node.getRight(), value));
        }

        return node;
    }

    // 遍历树（示例为中序遍历）
    public void traverse() {
        inOrderTraversal(root);
    }

    private void inOrderTraversal(TreeNode node) {
        if (node != null) {
            inOrderTraversal(node.getLeft());
            System.out.print(node.getValue() + " ");
            inOrderTraversal(node.getRight());
        }
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Tree tree = new Tree();

        // 插入节点
        tree.insert(5);
        tree.insert(3);
        tree.insert(7);
        tree.insert(2);
        tree.insert(4);
        tree.insert(6);
        tree.insert(8);

        // 遍历树
        tree.traverse();
    }
}