输入模板

import java.util.Scanner;

public class Oj {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入字符串
        String str = scanner.next(); // 读取输入的字符串

        // 读取整行输入
        String line = scanner.nextLine();

        // 输入基本类型
        int num = scanner.nextInt(); // 读取输入的整数
    }
}

输出模板

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        //输出
//		使用System.out.println()方法：	
        System.out.println("Hello, World!");
//		使用System.out.print()方法：	
        System.out.print("Hello, World!");
//		使用System.out.printf()方法进行格式化输出：
        System.out.printf("The number is: %d", num);
    }
}

格式化输出详细介绍

System.out.format(); System.out.printf();
俩者用法一致，下面以format举例说明。
当我们需要格式化输出一些数据，只是使用System.out.println();就有点不够用了，这时就需要用到format方法了

System.out提供了格式化的输出方法format，format的第一个参数是一个模板，模板面有一些占位符，再通过后面的参数替换模板中的占位符完成整个信息的输出

占位符

常用占位符：

占位符	说明
%d	格式化输出整数
%f	格式化输出浮点数
%e	格式化科学计数法的浮点数
%s	格式化输出字符串

        int x=5;
        System.out.println("x="+x);
        String name="LiLi";
        int age=8;
        char sex='男';
        double grade=28.8;
        System.out.format("姓名:%s, 年龄:%d, 性别:%c, 成绩:%.1f\n", name, age, sex, grade);

其中%c,%s等就叫做占位符，分别代表字符和字符串，它们将被后边出现的对应的变量的值替换掉。像%.1f是%f中又添加了.f 表示输出一个1位的小数。

fomat

format 是一个用于格式化字符串的函数或方法，它可以在程序中将变量的值插入到字符串中，从而得到一个格式化后的字符串。

格式化整数

既可以格式化基本数据类型，也可以格式化它们的包装类

%d :格式化十进制整数
%o :格式化八进制整数
%x :格式化小写十六进制整数，如：abc58
%X :格式化大写十六进制整数，如：ABC58

修饰符

“+”：格式化正整数时强制添加上正好，如%+d可将123格式化位+123
“,”：格式化整数时按“千”分组，例如：%,d可将1234567890格式化位1,234,567,890
它俩可以组合使用，如：%+,d

数据的宽度

%md或%-md指定格式化整数的长度最少为m

如%6d可将123格式化为“ 123”，左边三个空格，即如果数字的长度不足6，则在格式化的数字左边添加空格使得整体长度为6（左边添加空格即右对齐）
%-6d使得结果左对齐，即在右边添加空格，如%-6d可将123格式化为“123 ”，右边三个空格

例子

//	格式化字符串
        int n = 500000000;
        System.out.format("     500000000的八进制整数:%o",n);//八进制整数
        System.out.format("     500000000的十进制整数:%d",n);//十进制整数
        System.out.format("     500000000的十六进制整数小写:%x",n);//十六进制整数小写
        System.out.format("     500000000的十六进制整数大写:%X",n);//十六进制整数大写
        System.out.println();
        System.out.println("    ---修饰符---");
        System.out.format("     500000000的格式化正整数:%+d",n);
        System.out.format("     500000000的格式化分组整数:%+,d",n);
        System.out.println("    ---数据的宽度---");
        int n1 = 123;
        System.out.format("     左对齐%-6d",n1);

格式化浮点数

既可以格式化基本数据类型，也可以格式化它们的包装类

修饰符

“+” ：格式化正数时添加正号
“,”：将正数部分按千分位
它俩可以组合使用，如：%+,f

限制小数位数与宽度

“%.nf”可以限制小数的位数为n（遵循四舍五入）
“%mf”可以规定数据的宽度为m，长度不足补空格，默认居右（%-mf，居左）
组合使用：

System.out.printf("%7.3f",0.1235);

结果：0.124 （还有俩个空格，“.”也占一个长度）

基本数据类型和字符串

1.常用基本数据类型

数据类型	内存	取值（十进制）
int	32位	-10^10~10^10
long	64位	-10^19~10^19
double	64位	4.910^-324~1.7910^3084.9E-324~1.79E308
char	16位
boolean	1位

Java的八种基本类型：（按字节来分）

boolean 布尔型 1个字节 8bit（8位）

byte 字节类型 1个字节

char 字符类型 2个字节

short 短整型 2个字节

int 整型 4个字节

float 浮点型（单精度）4个字节

long 长整型 8个字节

double 双精度类型 8个字节

Java中默认的整数类型是int，如果要定义为long ，则要在数值后加上L或者l

默认的浮点型是双精度浮点，如果要定义float，则要在数值后面加上f或者F

一个字节等于8位，1个字节等于256个数。2^8

一个英文字母或者阿拉伯数字占一个字节

一个汉字占2个字节

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	‘u0000’
String (or any object)	null
boolean	false

2.字符串（String类）

（1）创建

String str=new String();
//为什么不用实例化可以使用String类？
//String底层是通过string数据类型实现的
String str="";

（2）操作方法

// 连接字符串和其他类型
String s1 = "Hello";
String s2 = "World";
String str1 = s1 + s2;      // 与字符串连接
int in = 42;
String str2 = in + s1;      // 与int类型连接
String str3 = String.valueOf(in); // int转String
// 注意：以下这行是错误的，需要使用String.valueOf方法或者直接将int转换为String
// String str4 = in;

// 获取信息
// 1. 长度
int length = str1.length();

// 2. 查找字符串
int indexOfA = str1.indexOf("a");               // 查找字符串a首次出现的位置
int lastIndexOfA = str1.lastIndexOf("a");       // 查找字符串a最后出现的位置
int indexOfAB = str1.indexOf("ab");             // 查找字符串ab首次出现的位置
int lastIndexOfAB = str1.lastIndexOf("ab");     // 查找字符串ab最后出现的位置

// 3. 获取和截取字符串
String subStr1 = str1.substring(3);            // 获取索引为3(包含)~length(不包含)的字符串
String subStr2 = str1.substring(3, 6);         // 获取索引为3(包含)~6(不包含)的字符串

// 4. 字符串的替换
String replacedStr = str1.replace("a", "A");   // 将字符串str1中的a替换为A

// 5. 判断字符串的开头或结尾
boolean startsWith = str1.startsWith("Hello"); // 以"Hello"开头返回true，否则false
boolean endsWith = str1.endsWith("World");      // 以"World"结尾返回true，否则false

// 6. 判断字符串是否相等
boolean isEqual = str1.equals("HelloWorld");    // 相等返回true，否则false

// 7. 字符串比较（按字典顺序）
int compareResult = str1.compareTo("Abc");     // 比较str1和"Abc"，返回正整数、0、负整数

// 8. 字符串的大小写转换
String lowerCaseStr = str1.toLowerCase();     // 转换为小写
String upperCaseStr = str1.toUpperCase();     // 转换为大写

// 9. 字符串的分割
String[] arr1 = str1.split("/");               // 使用'/'分割字符串
String[] arr2 = str1.split("\\.");             // 使用'.'分割字符串（'.'是特殊字符需要使用双反斜杠转义）

// 注意：除了'.'和'|'等特殊字符，通常不需要额外转义。

3.数据类型转换

//1基本数据类型转String类
in+"";//int转String，其他同理
//2包装类转String类
i.toString();//Integer类转String
//String类转基本数据类型和包装类
Integer.parseInt(str);//String转int型或Integer,其他同理

在Java中，您可以使用不同的方式进行数据类型转换，具体取决于您需要执行的转换类型和情况。以下是一些常见的数据类型转换示例：

隐式类型转换（自动类型转换）：隐式类型转换是指将一个小范围的数据类型转换为一个大范围的数据类型，这种转换是自动进行的，不需要特殊操作。例如，将一个整数转换为浮点数：

int myInt = 10;
double myDouble = myInt; // 隐式类型转换，将int转换为double

显式类型转换（强制类型转换）：显式类型转换是指将一个大范围的数据类型转换为一个小范围的数据类型，这种转换需要使用强制类型转换运算符（例如(类型)）进行。需要注意的是，在这种情况下可能会发生数据丢失。例如，将一个浮点数转换为整数：

double myDouble = 10.5;
int myInt = (int) myDouble; // 显式类型转换，将double转换为int，小数部分被截断

使用包装类进行转换：对于基本数据类型，您可以使用包装类来进行类型转换。例如，将字符串转换为整数：

String str = "123";
int myInt = Integer.parseInt(str); // 使用Integer包装类的parseI

基本数据类型转换为String类：

int myInt = 42;
String intAsString = myInt + ""; // int转String

包装类转换为String类：

Integer myInteger = 123;
String integerAsString = myInteger.toString(); // Integer类转String

String类转换为基本数据类型和包装类：

String str = "456";
int strAsInt = Integer.parseInt(str); // String转int
Integer strAsInteger = Integer.valueOf(str); // String转Integer

数组操作

二维数组

二维数组是最常见的多维数组形式。它可以看作是行和列的矩阵，每个元素由两个索引来确定。

声明和创建二维数组的语法如下：
```
dataType[][] arrayName = new dataType[rows][columns];
```
其中，dataType 是数组元素的数据类型，rows 表示行数，columns 表示列数。

示例：
```
int[][] matrix = new int[3][4]; // 创建一个3行4列的二维整数数组
```

初始化

初始化二维数组：二维数组可以通过嵌套的循环进行初始化，或者使用静态初始化方法，将初始值直接赋给数组元素。

静态初始化示例：
```
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
```
访问二维数组元素：使用两个索引来访问二维数组中的元素，一个索引表示行号，另一个表示列号。例如：
```
int value = matrix[1][2]; // 访问第2行第3列的元素，值为6
```
多维数组： Java也支持更高维度的数组，例如三维数组、四维数组等。其声明和访问方式类似，只是需要使用多个索引来访问元素。

示例：
```
int[][][] threeDimensionalArray = new int[2][3][4]; // 创建一个2x3x4的三维整数数组
int value = threeDimensionalArray[1][2][3]; // 访问第2个二维数组中的第3
```

public class ArrayExample {
    public static void main(String[] args) {
        // 声明和创建数组
        int[] numbers = new int[5];
        
        // 初始化数组元素
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;
        
        // 访问数组元素并打印
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println(); // 换行
        
        // 使用增强型for-each循环遍历数组元素并打印
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        System.out.println(); // 换行
        
        // 创建和处理多维数组（二维数组）
        int[][] matrix = new int[3][3];
        int value = 1;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                matrix[i][j] = value;
                value++;
            }
        }
        
        // 打印二维数组
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println(); // 换行
        }
        
        // 使用Arrays类的方法
        int[] sortedArray = {5, 2, 9, 1, 5, 6};
        Arrays.sort(sortedArray); // 排序数组
        System.out.println("Sorted Array: " + Arrays.toString(sortedArray));
        
        int[] newArray = Arrays.copyOf(sortedArray, 4); // 复制数组
        System.out.println("Copied Array: " + Arrays.toString(newArray));
    }
}

增强性for-each循环

增强型for循环，是Java编程语言中的一种语法结构，用于遍历数组、集合和其他可迭代对象的元素，以简化代码编写和提高可读性。它在Java 5及更高版本中引入，是一种迭代集合的更方便的方式。

增强型for-each循环的语法如下：

for (elementType element : iterable) {
    // 执行操作，使用element访问当前元素
}

其中：

elementType 是集合中元素的数据类型。
element 是循环的变量，它代表当前迭代的元素。
iterable 是要遍历的集合、数组或其他可迭代对象。

使用增强型for-each循环，您可以逐个访问集合中的元素，而不需要手动管理索引或使用传统的for循环。这可以减少编码错误，提高代码的可读性，并使代码更加简洁。

以下是一个使用增强型for-each循环遍历数组的示例：

int[] numbers = {1, 2, 3, 4, 5};

for (int num : numbers) {
    System.out.println(num);
}

这段代码会依次打印数组numbers中的每个元素，不需要显式指定索引。增强型for-each循环适用于大多数需要遍历集合或数组的情况，并且使代码更易读和维护。

包装类

1.常用包装类

1.Integer 2.Long 3.Boolean 4.Character 5.Double
注意：必须分配内存空间才能使用
Integer in=new Integer("0");

2.包装类常用的方法

//1.比较值大小
in.compareTo(otherin);//in>otherin返回正值,in=otherin返回0,in<other返回负值
//2.返回一个字符串
in.toString();//可转换为字符串
//3.返回包装类对象
Integer in=Integer.valueOf(33);//返回一个Integer对象
//4.以基本类型返回包装类对象
Integer in=new Integer("33");
int i=in.intValue();
//5.对象的比较
in.equals(otherin);//相等则返回true,否则false
//常数
Integer.MAX_VALUE;//2^31-1;
Integer.MIN_VALUE;//-2^31;

解释

Java包装类是一种用于将基本数据类型转换为对象的类。它们提供了一种将基本数据类型（如int、double、boolean等）封装为对象的方式，以便可以在需要时进行对象操作。以下是Java包装类的一些常见用法示例：

自动装箱和拆箱：

自动装箱是将基本数据类型自动转换为包装类对象的过程，而拆箱是将包装类对象自动转换回基本数据类型的过程。这些操作在Java 5及更高版本中引入。

// 自动装箱
Integer num = 10; // 将整数10自动装箱为Integer对象

// 拆箱
int value = num; // 将Integer对象num自动拆箱为基本整数类型

使用包装类进行类型转换：

包装类提供了方法来进行类型转换，例如将字符串转换为整数或将整数转换为字符串。

// 将字符串转换为整数
String str = "123";
int intValue = Integer.parseInt(str);

// 将整数转换为字符串
int num = 456;
String strValue = Integer.toString(num);

包装类的常用方法：

包装类提供了许多常用的方法，例如比较、取值范围、转换等。以下是一些示例：

Integer a = 5;
Integer b = 10;

int max = Integer.max(a, b); // 获取两个整数中的最大值
int min = Integer.min(a, b); // 获取两个整数中的最小值

boolean isEqual = a.equals(b); // 比较两个整数是否相等

int intValue = a.intValue(); // 获取Integer对象的整数值

使用包装类处理特殊值：

包装类可以用来表示特殊值，例如null或NaN（不是一个数字）。

Integer nullValue = null; // 表示空值
Double nanValue = Double.NaN; // 表示不是一个数字

数据处理类

Math类

//1.常用的数字常量
Math.PI;//常量π
//2.指数函数
Math.exp(a);//返回e^a
Math.sqrt(a);//返回a的平方根
Math.cbrt(a);//返回a的立方根
Math.pow(a,b);//返回a^b
//3.取值
Math.max(a,b);//返回a,b当中的最大值
Math.min(a,b);//返回a,b当中的最小值
Math.abs(a);//返回a的绝对值
//4.取整
Math.floor(a);//向下取整:5.5->5
Math.ceil(a);//向上取整:5.5->6
Math.rint(a);//四舍五入,返回double
Math.round(a);//四舍五入,返回int或long(输入float或double)

2.大数字类

//注意：使用时必须分配内存，因为是类
//大整数类
//1.常数
BigInteger.ONE;
BigInteger.ZERO;
BigInteger.valueOf(long a);
//2.创建
BigInteger Big=new BigInteger("2");
BigInteger Big=常数;
//3.运算
Big.add(otherBig);        //加
Big.subtract(otherBig);   //减
Big.multiply(otherBig);   //乘
Big.divide(otherBig);     //除
Big.remainder(yushu);Big.mod(yushu);//取模或取余，正数时没区别
//4.取值
Big.max(otherBig);        //返回两数之间最大值
Big.min(otherBig);        //返回两数之间最小值

 public static void main(String[] args) {
        // Math类示例
        double pi = Math.PI; // 常量π

        double expResult = Math.exp(2.0); // 返回e^2
        double sqrtResult = Math.sqrt(25.0); // 返回25的平方根
        double cbrtResult = Math.cbrt(8.0); // 返回8的立方根
        double powResult = Math.pow(2.0, 3.0); // 返回2^3

        int maxResult = Math.max(5, 10); // 返回5和10中的最大值
        int minResult = Math.min(5, 10); // 返回5和10中的最小值
        double absResult = Math.abs(-7.5); // 返回-7.5的绝对值

        double floorResult = Math.floor(5.5); // 向下取整，结果为5.0
        double ceilResult = Math.ceil(5.5); // 向上取整，结果为6.0
        double rintResult = Math.rint(5.5); // 四舍五入，结果为6.0
        long roundResult = Math.round(5.5); // 四舍五入，结果为6

        // BigInteger和BigDecimal示例
        BigInteger bigInt1 = new BigInteger("123456789012345678901234567890");
        BigInteger bigInt2 = BigInteger.valueOf(987654321098765432109876543210);

        BigInteger sum = bigInt1.add(bigInt2); // 加法
        BigInteger difference = bigInt1.subtract(bigInt2); // 减法
        BigInteger product = bigInt1.multiply(bigInt2); // 乘法
        BigInteger quotient = bigInt1.divide(bigInt2); // 除法
        BigInteger remainder = bigInt1.remainder(bigInt2); // 取余

        BigDecimal bigDecimal1 = new BigDecimal("123.456");
        BigDecimal bigDecimal2 = BigDecimal.valueOf(987.654);

        BigDecimal sumDecimal = bigDecimal1.add(bigDecimal2); // 加法
        BigDecimal differenceDecimal = bigDecimal1.subtract(bigDecimal2); // 减法
        BigDecimal productDecimal = bigDecimal1.multiply(bigDecimal2); // 乘法
        BigDecimal quotientDecimal = bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_HALF_UP); // 除法，保留2位小数，四舍五入
    }

集合类

Collection接口

Collection的子接口有List和Set
//常用方法
add(e);        //添加元素
remove(e);     //删除元素
clear();       //清空集合
isEmpty();     //返回boolean判断集合里全部元素是否为空
iterator();    //用于遍历
size();        //返回int,获取集合元素个数

（1）List接口

//list常用操作方法
set(i,value);  //修改索引为i的元素值,value为修改值
get(i);        //获取索引为i的元素（从0开始）
//1.创建集合
//根据频繁操作的复杂度选择，一般随便选
List<Object> al=new ArrayList<Object>();
List<Object> ll=new LinkedList<Object>();

//2.遍历
//(1).for
for(Object x:list)
    x;
for(int i=0;i<list.size();i++)
    list.get(i);
//(2)迭代器遍历
Iterator<Object> it=list.iterator();
while(it.hasNext)
    it.next();
//注意：List中的Remove和Collection的不一样remove(i)是索引而不是元素值

（2）Set接口

//优点：不能包含重复元素，可以去重
//1.创建集合
Set<Object> hs=new HashSet<Object>();
Set<Object> ts=new TreeSet<Object>();
//2.遍历
//(1)for
for(Object x:set)
    x;

//(2)迭代器遍历
Iterator<Object> it=set.iterator();
while(it.hasNext)
    it.next();

Map接口

//常用方法
put(key,value);    //添加元素
get(key);          //获取元素
remove(key);       //删除元素
clear();           //清空集合
contains(element);//判断是否在集合内
通过迭代器
//每个key只能映射一个value,可将key和value看成2个集合
//1.创建集合
Map<Object,Object> hm=new HashMap<Object,Object>();
Map<Object,Object> tm=new TreeMap<Object,Object>();
//2.遍历
//(1)for
//遍历key集合
for(int x:hm.keySet()) {
   System.out.println("key="+x+" "+"value="+hm.get(x));
}

//(2).迭代器遍历
Set<Integer> set=hm.keySet();
Iterator it=set.iterator();
while(it.hasNext)
    it.next();

3.关于迭代器

//常用方法
it.next()     //返回下一个元素
it.hasNext()  //是否有元素
it.remove()   //删除元素

常用的包

import java.math.*;
import java.util.*;

java数据结构

数据结构	特点
数组	固定大小，元素类型相同，快速随机访问
列表	动态大小，元素类型相同，支持插入和删除操作
集合	无序，不允许重复元素
映射	键值对存储，通过键来访问值
队列	先进先出（FIFO）
堆栈	后进先出（LIFO）
树	分层结构，常见的有二叉树、AVL树、红黑树等
图	表示各种关系，复杂的数据结构
链表	线性结构，包含节点和指向下一个节点的引用
哈希表	基于哈希函数的快速查找和插入数据结构

ava 的 java.util 包中提供了许多这些数据结构的实现，可以根据需要选择合适的类。

以下是一些常见的 Java 数据结构：

数组（Arrays）

数组（Arrays）是一种基本的数据结构，可以存储固定大小的相同类型的元素。

int[] array = new int[5];

特点： 固定大小，存储相同类型的元素。
优点： 随机访问元素效率高。
缺点： 大小固定，插入和删除元素相对较慢。

列表（Lists）

Java 提供了多种列表实现，如 ArrayList 和 LinkedList。

List<String> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();

ArrayList:

特点： 动态数组，可变大小。
优点： 高效的随机访问和快速尾部插入。
缺点： 中间插入和删除相对较慢。

LinkedList:

特点： 双向链表，元素之间通过指针连接。
优点： 插入和删除元素高效，迭代器性能好。
缺点： 随机访问相对较慢。

集合（Sets）

集合（Sets）用于存储不重复的元素，常见的实现有 HashSet 和 TreeSet。

Set<String> hashSet = new HashSet<>();
Set<Integer> treeSet = new TreeSet<>();

HashSet:

特点： 无序集合，基于HashMap实现。
优点： 高效的查找和插入操作。
缺点： 不保证顺序。

映射（Maps）

映射（Maps）用于存储键值对，常见的实现有 HashMap 和 TreeMap。

Map<String, Integer> hashMap = new HashMap<>();
Map<String, Integer> treeMap = new TreeMap<>();

HashMap:

特点： 基于哈希表实现的键值对存储结构。
优点： 高效的查找、插入和删除操作。
缺点： 无序，不保证顺序。

TreeMap:

特点： 基于红黑树实现的有序键值对存储结构。
优点： 有序，支持按照键的顺序遍历。
缺点： 插入和删除相对较慢。

栈（Stack）

栈（Stack）遵循先进后出（FILO）原则。

Stack<Integer> stack = new Stack<>();

Stack 类:

特点： 代表一个栈，通常按照后进先出（LIFO）的顺序操作元素。

队列（Queue）

队列（Queue）遵循先进先出（FIFO）原则，常见的实现有 LinkedList 和 PriorityQueue。

Queue<String> queue = new LinkedList<>();

Queue 接口:

特点： 代表一个队列，通常按照先进先出（FIFO）的顺序操作元素。
实现类： LinkedList, PriorityQueue, ArrayDeque。

堆（Heap）

堆（Heap）优先队列的基础，可以实现最大堆和最小堆。

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());

树（Trees）

Java 提供了 TreeNode 类型，可以用于构建二叉树等数据结构。

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

图（Graphs）

图的表示通常需要自定义数据结构或使用图库，Java 没有内建的图类。

以上介绍的只是 Java 中一些常见的数据结构，实际上还有很多其他的数据结构和算法可以根据具体问题选择使用。

其他一些说明

以下这些类是传统遗留的，在 Java2 中引入了一种新的框架-集合框架(Collection)，我们后面再讨论。

枚举（Enumeration）

枚举（Enumeration）接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。

例如，枚举定义了一个叫nextElement 的方法，该方法用来得到一个包含多元素的数据结构的下一个元素。

关于枚举接口的更多信息，请参见枚举（Enumeration）。

import java.util.Enumeration;
import java.util.Vector;

public class EnumerationExample {
    public static void main(String[] args) {
        // 创建一个Vector集合
        Vector<String> vector = new Vector<>();
        vector.add("Apple");
        vector.add("Banana");
        vector.add("Orange");

        // 获取Enumeration对象
        Enumeration<String> enumeration = vector.elements();

        // 使用Enumeration遍历集合元素
        while (enumeration.hasMoreElements()) {
            String element = enumeration.nextElement();
            System.out.println(element);
        }
    }
}

位集合（BitSet）

位集合类实现了一组可以单独设置和清除的位或标志。

该类在处理一组布尔值的时候非常有用，你只需要给每个值赋值一”位”，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。

关于该类的更多信息，请参见位集合（BitSet）。

向量（Vector）

向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。

和数组一样，Vector对象的元素也能通过索引访问。

使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。

关于该类的更多信息，请参见向量(Vector)

栈（Stack）

栈（Stack）实现了一个后进先出（LIFO）的数据结构。

你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。

当你从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出。

关于该类的更多信息，请参见栈（Stack）。

Java Stack 类

栈是Vector的一个子类，它实现了一个标准的后进先出的栈。

堆栈只定义了默认构造函数，用来创建一个空栈。堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。

Stack()

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

序号	方法描述
1	boolean empty() 测试堆栈是否为空。
2	Object peek( ) 查看堆栈顶部的对象，但不从堆栈中移除它。
3	Object pop( ) 移除堆栈顶部的对象，并作为此函数的值返回该对象。
4	Object push(Object element) 把项压入堆栈顶部。
5	int search(Object element) 返回对象在堆栈中的位置，以 1 为基数。

实例

下面的程序说明这个集合所支持的几种方法

实例

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); // 将元素 42 加入栈中
    showpush(st, 66); // 将元素 66 加入栈中
    showpush(st, 99); // 将元素 99 加入栈中
    showpop(st);      // 弹出栈顶元素并展示
    showpop(st);      // 弹出栈顶元素并展示
    showpop(st);      // 弹出栈顶元素并展示
    try {
        showpop(st);  // 弹出栈顶元素并展示，但是此时栈已经为空，会触发 EmptyStackException
    } catch (EmptyStackException e) {
        System.out.println("empty stack"); // 捕获 EmptyStackException 异常并打印 "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

字典（Dictionary）

字典（Dictionary）类是一个抽象类，它定义了键映射到值的数据结构。

当你想要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用 Dictionary。

由于 Dictionary 类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。

关于该类的更多信息，请参见字典（ Dictionary）。

Dictionary 类在较新的 Java 版本中已经被弃用（deprecated），推荐使用 Map 接口及其实现类，如 HashMap、TreeMap 等，来代替 Dictionary。

Map 接口及其实现类可以参考：Java 集合框架。

哈希表（Hashtable）

Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。

例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名。

哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

关于该类的更多信息，请参见哈希表（HashTable）。

属性（Properties）

Properties 继承于 Hashtable.Properties 类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。

Properties 类被许多Java类使用。例如，在获取环境变量时它就作为System.getProperties()方法的返回值。

关于该类的更多信息，请参见属性（Properties）。

算法学习路线

java数据结构与算法

数据结构

结构，简单理解就是关系，比如分子结构，就是说组成分子的原子之间的排列方式。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。在任何问题中，数据元素都不是孤立存在的，他们之间存在某种关系，这种数据元素相互之间的关系成为结构（Structure）。
数据结构包括三方面的内容：逻辑结构，存储结构和数据的运算。逻辑结构是面向问题的，物理结构是面向计算机的，其基本目标就是将数据及其逻辑关系存储到计算机内存中。
数据的逻辑结构和存储结构是密不可分的两个方面，一个算法的设计取决于所选定的逻辑结构，而算法的实现依赖于所采用的存储结构。
程序设计=数据结构+算法
想要编写一个质量高的程序，必须分析待处理对象的特性及各个处理对象之间存在的关系。

数据结构三要素

逻辑结构
存储结构
数据的运算

线性结构: 一对一的关系

集合：

输入模板

输出模板

格式化输出详细介绍

占位符

fomat

格式化整数

例子

格式化浮点数

基本数据类型和字符串

1.常用基本数据类型

Java的八种基本类型：（按字节来分）

2.字符串（String类）

（1）创建

（2）操作方法

3.数据类型转换

数组操作

二维数组

初始化

增强性for-each循环

包装类

1.常用包装类

2.包装类常用的方法

解释

自动装箱和拆箱：

使用包装类进行类型转换：

包装类的常用方法：

使用包装类处理特殊值：

数据处理类

Math类

集合类

Collection接口

（1）List接口

（2）Set接口

Map接口

3.关于迭代器

常用的包

java数据结构

数组（Arrays）

列表（Lists）

集合（Sets）

映射（Maps）

栈（Stack）

队列（Queue）

堆（Heap）

树（Trees）

图（Graphs）

其他一些说明

枚举（Enumeration）

位集合（BitSet）

向量（Vector）

栈（Stack）

Java Stack 类

实例

实例

字典（Dictionary）

哈希表（Hashtable）

属性（Properties）

算法学习路线

java数据结构与算法

数据结构

数学