Java 学习笔记

一.数据类型

1.基础的Java程序

public class test1_1 {
	public static void main(String[] args) {
        System.out.print("aaaaaaa");
    }
}

2.注释

public class test1_1 {
	public static void main(String[] args) {
		//单行注释
		/*
			多行注释
		 */
		/**
		 生成描述文档
		 */
        System.out.print("aaaaaaa");
    }
}

3.数据类型

1)整形

• int 4字节 (常用)
• short 2字节
• long 8字节 (常用)
• byte 1字节

2)浮点类型

• float 4字节
• double 8字节 (常用)

3)bool类型

• false
• true

4)字符

• char 'aaa'

5)字符串

package test1;

public class test1_1 {
	public static void main(String[] args) {
		String b = "12345啊";
		System.out.println(b.substring(1,3));//字符串切割 输出23
		System.out.println(b+b);//字符串拼接     输出 12345啊12345啊
		System.out.println(b.length());//输出字符串长度 输出6
		System.out.println(b.codePointCount(0, b.length()));//输出码点单元数量长度 输出5
		System.out.println(String.join("aaa","bbb","ccc"," ","123"));//字符串拼接  输出bbbaaacccaaa aaa123
		String c="12345啊";
		//字符串比较
		System.out.println(b!=c);//等于时返回 变量的值，不等时返回flase   这个是比较的指针 不能用
		System.out.println(b.equals(c));//比较是否相等，相等返回true
		System.out.println(b.equalsIgnoreCase(c));//比较时忽略大小写
		System.out.println(b.charAt(1));//同 b[1] 输出第一位的字母 
		System.out.println(b.compareToIgnoreCase(c));//比较assic码值大小 相等返回0，b大返回正数,b小返回负数
		System.out.println(b.startsWith("123"));
		System.out.println(b.endsWith("123"));//是否已123开始或结束
		//查找指定字符是在字符串中的下标。在则返回所在字符串下标；不在则返回-1.  
        System.out.println(b.indexOf("b")); // indexOf(String str); 返回结果：-1，"b"不存在  
        // 从第2个字符位置开始往后继续查找，包含当前位置  
        System.out.println(b.indexOf("3",1));//indexOf(String str, int fromIndex); 返回结果：2  
        System.out.println(b.lastIndexOf('a'));//同上，从最后一位开始
        System.out.println(b.replace("12","999"));//替换筛选 输出 999345啊
        System.out.println(b.substring(1,3));//字符串切割 同 b[2:3]
        //大小写转换
        System.out.println(b.toLowerCase());
        System.out.println(b.toUpperCase());
        System.out.println(b.trim());//去空格
        
        //多个重复的短字符拼接，节省空间
        StringBuilder builder=new StringBuilder();
        builder.append("111");
        builder.append("222");
        System.out.println(builder.append("333"));//添加元素，返回本体
        System.out.println(builder.toString());//转字符串
        System.out.println(builder.length());//字符串总长度
   
	}	
}

5)数组

数组用来存储同一类型的数据集合

(0)常用方法

int a[]=new int[5];
int b[]=new int[5];
int c[]=Arrays.copyOf(a, a.length);//数组复制
System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 4)));//返回一个数组，输出数组第二位与第三位
Arrays.sort(a);//数组排序，同 python sorted(a)
Arrays.fill(a, 11111);//数组填充，将数组中所有的值都变成11111
System.out.println(Arrays.equals(a, b));//比较a,b两数组是否一致，一致返回true

(1)基础声明

//创建数组的多种格式
		int a[]=new int[100];
		int[] b=new int[100];
		int[] c= {1,2,3};
		c=new int[]{123,111};//充实新初始化数组，只有在定义了d的时候才能这么用
		//简单的循环输出,int数组的默认为0,String默认为null
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]);
		}

(2)增强for循环

int a[]=new int[100];
        for (int i : a) {
			System.out.print(i);
		}//效果同python   for i in a:print(i,end='')
		System.out.print(Arrays.toString(a));//效果同python print(a)

(3)数组的深浅拷贝

int a[]=new int[5];
		int b[]=a;                         //浅拷贝 返回[1, 0, 0, 0, 0]
		int c[]=Arrays.copyOf(a, a.length);//深拷贝 返回[0, 0, 0, 0, 0]
		int d[]=Arrays.copyOf(a, a.length*2);//可以用来进行数组扩容 返回返回[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
		a[0]=1;
		System.out.println(Arrays.toString(b));
		System.out.println(Arrays.toString(c));
		System.out.println(Arrays.toString(d));
	    System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 4)));//返回一个数组，输出数组第二位与第三位

(4)main方法的String[] args

用 java test1_1 -h 调用

public class test1_1 {
	public static void main(String[] args){
		if (args[0].equals("-h")) {
			System.out.println(111);
		}
	}
}

(5)数组排序

Arrays.sort(a);//同 python sorted(a)

(6)二维数组

int [][] a=new int[10][10];
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				System.out.print(String.valueOf(10*i+j)+'\t');
			}
			System.out.println();
		}

简便写法

int[][] a=new int[10][10];
		for (int[] rows : a) {
			for (int values : rows) {
				System.out.print(String.valueOf(values)+'\t');
			}
		System.out.println();
		}

直接输出，同python print(a)

int[][] a=new int[10][10];
		System.out.println(Arrays.deepToString(a));

定义一个每行长度不一致的二维数组

int[][] a=new int[10][];
		for (int i = 0; i < a.length; i++) {
			a[i]=new int[i+1];
		}
		System.out.println(Arrays.deepToString(a));

4.变量与常量

1)变量

支持不推荐 int a,b;
支持 int a=1;

2)常量

final int AAA=1;//声明后元素值不可变,习惯上命名全大写

public static final double BBB=1.54;  //类常量，public 可以在别的类中使用

3)类型转换

int a =123456789;
float b=a;//类型转换
System.out.println(b); 
int c=(int) b;//强制类型转换
System.out.println(c); 
String.valueOf(12);//数字转字符串

5.运算符

x+=4;\\等价于
    x=x+4;

int a=7;
		int b=7;
		System.out.println(a++); //7
		System.out.println(++b); //8

1&&2   与
    1&2
    1||2   或

:?
    判断:正确返回值？错误返回值

二.输入输出

1.基础输入

package test1;

import java.io.Console;
import java.util.Scanner;

public class test1_1 {
	public static void main(String[] args) {
		
		  Scanner in =new Scanner(System.in); System.out.println(in.nextLine());//输入正行
		  System.out.println(in.next());//输入下个词
		  System.out.println(in.nextLine());//输入下个整数
		  System.out.println(in.hasNext());//输入的数据中是否还有词
		  
		  //只有在控制台好使
		  Console cons=System.console();
		  System.out.println(cons.readLine("USERNAME "));
		  System.out.println(cons.readPassword("password "));
		 
	}
}

循环输入

Scanner scanner=new Scanner(System.in);
		while (scanner.next().equals("Y")) {
			System.out.println(111);
		}
		scanner.close();

2.格式化输出

Double f=3333.33333333;
		System.out.printf("%,8.2f",f);//格式化输出，输出3333.33 一共8位，小数点后2位 逗号位增加的分隔符
		String zz= "111";
		int qqq=12345;
		System.out.println();
		System.out.printf("%s aaa %f bbb %d",zz,f,qqq);//输出 3,333.33111 aaa 3333.333333 bbb 12345
		System.out.println();
		System.out.printf("%tc",new Date());//输出当前时间

3.文件读写

System.out.print("111")//输出

三.条件语句

1.while 与 for 循环

public class test1_1 {
    public static void main(String[] args) {
        int a = 10;
        while (a > 12) {
            a = a -1;
        }
        for (int x = 0; x < 10; x = x + 1) {
         System.out.println("x is now " + x);
        }
    }
}

2.if else

public class test1_1 {
    public static void main(String[] args) {
       String name = "aaa" ;
	        int x = 1;
	        if (x == 10) 
	        {
	            System.out.print("x must be 10");
	        }
	        else if (x == 11) {
				System.out.println("1111111");
			}
	        else 
	        {
	            System.out.print("x isn’t 10");
	        }
	        System.out.println();
	        if ((x < 3) & (name.equals("Dirk"))) 
	        {
	            System.out.println("Gently");
	        }
	        System.out.print("this line runs no matter what");
    }
}

注：

• name.equals("Dirk") ：判断是否相等 返回 bool
• java中 ' 与 " 不同

3. do while 语句

int a=1; 
		do {
			 System.out.println(111);
		 }
		while (a==2);

4.break的特殊用法

java中存在break与continue
在java中，支持用break实现goto的语法,实现跳转

public static void main(String[] args){
		int a=1;
		first_point://标签
		while (a>0 && a<50) {
			a=a+1;
			while(a>1){
				a=a+1;
				if (a>100) {
					break first_point;//跳转到标签
				}
			}
		}
		System.out.println("finish");
	}

四.集合

学习网址

1.java怎么学习集合？知乎

集合脑图

1.Collection的基础功能

2.Iterator 迭代器

一)Iterator迭代器介绍

1. 作用：遍历集合
2. 拥有方法
   hasNext()
   next()
   remove()

3.list

一)List集合介绍

1. 作用：有序(存储顺序和取出顺序一致),可重复
2. 自己的方法：
   ListIterator可以往前遍历，添加元素，设置元素
3. List集合常用子类

• ArrayList：底层数据结构是数组。线程不安全
• LinkedList：底层数据结构是链表。线程不安全
• Vector：底层数据结构是数组。线程安全

二)ArrayList

1.ArrayList属性

2.ArrayList定义方法

ArrayList<String> list = new ArrayList<>();

4.set

一)set集合介绍

1. 作用：元素不可重复
2. Set集合常用子类

• HashSet集合：底层数据结构是哈希表(是一个元素为链表的数组)
• TreeSet集合：底层数据结构是红黑树(是一个自平衡的二叉树);保证元素的排序方式
• LinkedHashSet集合：底层数据结构由哈希表和链表组成。

5.map

1. 作用：键值对
2. map集合常用方法

6.临时笔记1

三、List、Set、Map的值能否为null？

（1）List —— 允许为null

1、可以看到ArrayList可以存储多个null，ArrayList底层是数组，添加null并未对他的数据结构造成影响。

public void testArrayList(){
        ArrayList<String> list = new ArrayList<>();
        list.add(null);
        list.add(null);
        Assert.assertEquals(2,list.size()); // success
    }

2、LinkedList底层为双向链表，node.value = null 也没有问题。

public void testLinkedList(){
        LinkedList<String> list = new LinkedList<>();
        list.add(null);
        list.add(null);
        Assert.assertEquals(2,list.size()); // success
    }

3、Vector 底层是数组，所以不会管你元素的内容是什么，可以存储多个null。

public void VectorTest(){
        Vector box = new Vector();
        box.add(null);
        box.add(null);
        Assert.assertEquals(2,box.size()); //success
    }
 
    //Vector的add函数源码
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

（2）Set

1、HashSet底层是HashMap，可以有1个为null的元素。

public void testHashSet(){
        HashSet<String> set = new HashSet<>();
        set.add(null);
        Assert.assertEquals(1,set.size()); //OK size = 1
        set.add(null);
        Assert.assertEquals(2,set.size()); //Error size = 1
 
    }

2、LinkHashSet底层也是hashmap，允许存在一个为null的元素。
3、TreeSet不能有key为null的元素，会报NullPointerException

public void testTreeSet(){
        TreeSet<String> set = new TreeSet<>();
        set.add(null); //Error NullPointException
    }

（3）Map

1、HashMap中只能有一个key为null的节点。因为Map的key相同时，后面的节点会替换之前相同key的节点。

public void testHashMap(){
        HashMap<String,String> map = new HashMap<>();
        map.put(null,null);
        Assert.assertEquals(1,map.size()); //OK size = 1
 
        map.put(null,null);
        Assert.assertEquals(2,map.size()); //Error size = 1
    }

2、TreeMap的put方法会调用compareTo方法，对象为null时，会报空指针错。

public void testTreeMap(){
        TreeMap<String,String> map = new TreeMap<>();
        map.put(null,null);
        Assert.assertEquals(1,map.size()); //Error NullPointException
        
    }

3、HashTable底层为散列表，无论是key为null，还是value为null，都会报错

public void HashTableTest(){
        Hashtable table = new Hashtable();
        table.put(new Object(),null); //Exception
        table.put(null,new Object()); //Exception
        table.put(null,null); //Exception
        Assert.assertEquals(1,table.size());
    }
 
    //hashTable  put函数源码
   public synchronized V put(K key, V value) {
        if (value == null) {   //value 需要判空，所以value不可为null
            throw new NullPointerException();
        }
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();     //key需要拥有实例去调用hashCode方法，所以也不能为空
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
        addEntry(hash, key, value, index);
        return null;
    }

7.临时笔记2

package basic;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

//List使用方法
public class ListDemo {

    public static void main(String[] args) {
        // 实例化直接赋值
        List<String> alpha = Arrays.asList("a", "b", "c", "d");
        dataPrintByFE(alpha);

        // 实例化List
        List<String> lists = new ArrayList<String>();

        // 添加元素
        lists.add("a");
        lists.add("b");
        lists.add("c");
        lists.add("d");
        dataPrintByIt(lists);
        lists.add(3, "e");
        dataPrintByIt(lists);

        // 修改元素
        lists.set(4, "f");
        dataPrintByIt(lists);

        // 删除元素(index或object)
        lists.remove(0);
        lists.remove("b");
        dataPrintByForEach(lists);

        // 查询
        String item = lists.get(1);
        int n = lists.indexOf("f");
        System.out.print("get：" + item + "  indexOf：" + n);

        // 遍歷(原始方法和新特性)
        dataPrintByIt(lists);
        dataPrintByForEach(lists);

        // 清空
        // lists.clear();

        // 直接输出
        System.out.println("直接输出：" + lists);

        // Java8处理输出
        List<String> collect = lists.stream().map(String::toUpperCase).collect(Collectors.toList());
        System.out.println("Java8的stream输出：" + collect); // [A, B, C, D]

    }

    // 遍历list-原始方法
    public static void dataPrintByIt(List<String> lists) {
        Iterator<String> it = lists.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();
    }

    // 遍历list-forEach方法，Java8新特性
    public static void dataPrintByForEach(List<String> lists) {
        lists.forEach((x) -> System.out.print(x + " "));
        System.out.println();
    }

    // 遍历list-forEach方法
    public static void dataPrintByFE(List<String> lists) {
        for (String item : lists) {
            System.out.print(item + " ");
        }
        System.out.println();
    }

}