1 容器
1.1 list
1.1.1 ArrayList
1.1.1.1 底层为数组实现
1.1.1.2 使用连续内存，可实现随机存取
1.1.2 LiKedList
1.1.2.1 底层实现是一个双向循环链表
1.1.2.2 可以使用碎片内存，不能随机存取，但增删元素，只需更改引用，有更好的性能
public class Test01 {
public static void main(String[] args) {
// 从Java 5 开始，容器可以指定泛型参数来限定容器中对象引用的类型
// 带泛型参数的容器比不带泛型参数的容器在使用上更加方便
// 从 Java 7 开始构造器后面的泛型参数可以省略- 钻石语法
// list 两个实现版本的比较
// ArrayList - 底层实现是一个数组 ， 使用连续内存 ，可以实现随机存取
// LinkedList - 底层实现是一个双向循环链表 ， 可以使用碎片内存 ， 不能随机存取
// 但是增删元素是需要修改引用即可 可以增删元素时更好的性能
List list = new LinkedList<>();
// List list = new ArrayList<>();
list.add("apple");
list.add("grape");
list.add("banana");
list.add("apple");
list.add("stawberry");
// 容器中只能放对象的引用，不能放基本数据类型
// 当你向容器中添加基本数据类型时会自动装箱（auto-boxing)
// 所谓自动装箱就是将基本数据类型处理成对应的包装类型
// list.add(1000);//list.add(new Integer(1000));
// list.add(3.14);
// list.add(new Date());
// list.add(true);
// 从Java 8 开始可以给容器发送forEach消息对元素进行操作
// forEach方法的参数可以是方法引用也可以是Lambda表达式
// 方法引用
// list.forEach(System.out::println);
// Lambda表达式
list.forEach(e -> {
System.out.println(e.toUpperCase());
});
System.out.println("===============");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("==============");
list.remove(0);
List temp = Arrays.asList("apple", "banana");
// list.removeAll(temp);//根据指定参考系删除所有
list.retainAll(temp);// 根据指定参考系保留所有
// list.remove(new Integer(1000));
list.remove(0);
list.add(list.size(), "shit");
for (String object : list) {
System.out.println(object);
}
System.out.println("==============");
list.clear(); //清空
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}}}
1.2 set
1.2.1 HashSet
1.2.1.1 不能放重复元素，没有get方法，也没有索引方法
1.2.1.2 要使用HashSetb必须重写量个方法
1.2.1.2.1 hashCode
1.2.1.2.1.1 让两个不同的对象产生不同的哈希码，
1.2.1.2.2 equals
1.2.1.2.2.1 定义比较两个对象的规则，（引用，类型，属性）
1.2.1.2.2.1.1 自反性
1.2.1.2.2.1.2 传递性
1.2.1.2.2.1.3 一致性
1.2.1.2.2.1.4 对称性
1.2.2 TreeSet
1.2.2.1 底层实现为排序树
1.2.2.2 使用treeSet
1.2.2.2.1 对象必须是可比较的，通过实现Comparable接口，
1.2.2.2.2 必须重写compareTo方法
public class Test01 {
public static void main(String[] args) {
Set set = new TreeSet<>();
set.add("apple");
set.add("grape");
set.add("blueberry");
set.add("pitaya");
set.add("啊");
System.out.println(set.size());
for (String string : set) {
System.out.print(string.hashCode()+ "----->");
System.out.println(string);
}
System.out.println("==============");
set.remove("pitaya");
Iterator< String > it=set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("============");
set.clear();
System.out.println(set.size());
}}
1.3 Map
1.3.1 HashMap
1.3.2 TreeMap
public abstract class Test01 {
public static void main(String[] args) {
//Map
//Map map=new HashMap<>();
Map map = new TreeMap<>();
map.put("applle","苹果");
map.put( "grape","葡萄");
map.put("shit","狗屎");
map.put( "banana","苹果");//将1号key替换了banana
System.out.println(map.size());
//map.remove(100);
for (String key : map.keySet()) {
System.out.println(key +"----->"+map.get(key));
}
}
}
1.4 只能放对象引用，不能放基本数据类型
1.4.1 auto -boxing自动装箱-将基本数据类型处理成对应的包装类型
1.4.1.1 int ---->Interger对象
1.4.2 auto-unboxing（自动拆箱） - 将包装类型处理成基本数据类型
1.4.2.1 Interger对象---->int
2 泛型参数
2.1 泛型-（gensric)-让类型不在是程序中的硬代码（hard-code）
2.1.1 此处的extends 不是继承，而是泛型限定，限定T类型必须是 Comparable接口的子类型
public static > void
bubbleSort(T[] array) {
boolean swapped = true;
for (int i = 1; swapped && i < array.length; i++) {
swapped = false;
for (int j = 0; j < array.length - 1; j++) {
if (array[j].compareTo(array[j + 1]) > 0) {
T temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
swapped = true;
}} }}
3 字符串
3.1 String
3.1.1 是不可变字符串，对字符串的修改会产生新的字符串
public class MyFrame extends JFrame {
//滚动显示
public MyFrame (){
this.setTitle("滚动字幕");
this.setSize(400,100);
this.setResizable(false);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
JLabel label = new JLabel("欢*迎*来*到*成*都*千*锋* ");
label.setFont(new Font("微软雅黑", Font.PLAIN,32));
this.add(label);
Timer timer = new Timer(500, evt->{
String string = label.getText();
String string2 = string.substring(1)+string.charAt(0);
label.setText(string2);
});
timer.start();
}
public static void main(String[] args) {
new MyFrame().setVisible(true);
}}
3.2 StringBuffer
3.2.1 可变字符串-是线程安全的，多个线程可以操作同一个StringBuffer对象
3.3 StringBuilder
3.3.1 Java 5 引入的可变字符串类型，
3.3.2 可变字符串-是线程不安全的，多个线程可以操作同一个StringBuilder对象,会产生错误
3.4 如果要频繁的修改一个字符串，请不要使用String,因为没次修改都会创建新的对象, 所以要使用StringBuffer或StringBuilder，后者性能更佳
public class Test03 {
public static void main(String[] args) {
StringBuilder string= new StringBuilder("");
long start = System.nanoTime();
for (int i=0 ;i<=100_000;i++){
string.append("a");
}
System.out.println(string);
long end = System.nanoTime();
System.out.println((end-start)/1e9 +"s");
}}
4 正则表达式
4.1 http://deerchao.net/tutorials/regex/regex-1.htm
public class Test04 {
//正则表达式 -regular expression
//定义字符串的匹配模式
public static void main(String[] args) {
//验证手机号会否符合规范
String str ="13234567890";
boolean isValid =str.matches("1[34578][0-9]{9}");
System.out.println(isValid);
//检查qq好是否正确
String qq= "24567345";
boolean isValidQQ = qq.matches("[1-9]\\d{4,}");
System.out.println(isValidQQ);
//检查用户名是否可用
String name = "asdfg12345_";
//boolean isnameValid = name.matches("[^a-zA-Z0-9]{6,20}");
boolean isnameValid = name.matches("\\w{6,20}");
System.out.println(isnameValid);
//利用正则表达式过滤敏感信息
String msg = "XXX，我操你大爷，日你二爷，干你三爷，fuck你四爷";
msg = msg.replaceAll("^ |[草日干操]|[Ff]\\s*[uU]\\s*[cC]\\s*[Kk]\\s*|XXX| $", "*");
System.out.println(msg);
//分段
String sentence = " You go your way,I will go main!";
String word[] =sentence.split("[\\s,!]");
for (String world : word) {
System.out.println(world);
}
}
}