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 顺序表:

顺序表的实现：

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

顺序表的创建和初始化：

java">	/*** 创建空的顺序表*/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];}}

获取指定下标的元素：

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

指定位置插入元素：

java">  /*** 指定位置插入元素** @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("表已满，无法插入");}}}

删除指定下标元素：

java">    /*** 删除指定下标元素** @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--;}}

其他操作：

java">    /*** 在表尾添加元素** @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;}

输出顺序表的元素：

java">     /*** 重写toString(),输出表中元素** @return*/@Overridepublic 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();}}

代码测试:

java">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类。

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

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

字符串长度获取

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

java">int len = str.length();

连接字符串

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

java">//String对象的连接
str1.concat(str2);"两个字符串连接结果："+str1+str2;

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

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

获取指定位置的字符串

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

java">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)

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

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

String trim()方法

java">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是正则表达式，替换成功返回替换的字符串，替换失败返回原字符串

java">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结束

java">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 比较，不考虑大小写

java">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 的值。

java">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型：

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

String转long型：

java">long l = Long.parseLong(String str);

String转double型：

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

int转string型：

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

字符大小写转换

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

java">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为分割份数

java">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()：将此字符串转换为一个新的字符数组。

java">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 数组中。

java">byte[] Str2 = Str1.getBytes();

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

创建StringBuffer字符串

java">StringBuffer str = new StringBuffer("");

添加字符(最常用方法)

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

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

删除字符串中的指定字符

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

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

翻转字符串

public StringBuffer reverse()

java">str.reverse();

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

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

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

java">str.insert(1,2);

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

java">str.length();
str.setLength(4);

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

java">str.capacity();

将其转变为String
String toString()

java">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定义的所有方法，也定义了自己的一些方法。

java">Stack()

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

实例：

java">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");}}
}

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

java">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来用。

java">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);}}
}

java">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)

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

java">// 节点类
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();}
}

2.7 二叉树

二叉树的结构就是一个父节点挂一个或者两个子节点

2.8 二叉搜索树

2.9 图

2.10 邻接矩阵

2.11 邻接表

2.12 哈希表；

3. 刷一些基础的算法题，提升编程思维：

3.1 线性枚举，

3.2 排序，

3.3 模拟

3.4 贪心

3.5 二分枚举

3.6 深搜

3.7 广搜