一、java基本数据类型

java中包含引用数据类型和八种基本类型

八种基本类型：

基本类型	占用空间（bit）	说明	默认值	包装类
byte	8	有符号的，以二进制补码表示的整数，范围-128（-2 ^7）~ 127（2 ^7-1）	0	Byte
short	16	有符号短整型	0	Short
int	32	有符号整型	0	Integer
long	64	有符号长整型	0L	Long
float	32	单精度浮点	0.0f	Float
double	64	双精度浮点	0.0d	Double
char	16	单一的 16 位 Unicode 字符		Character
boolean	8	布尔类型（true/false）	false	Boolean

打印包装类的基本信息

System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
System.out.println("包装类：java.lang.Double");  
System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);

基本数据类型都对应了其包装类，支持自动装箱和拆箱。

//自动装箱Integer x = Integer.valueOf(5)
Integer x = 5;
//拆箱，实际上执行了 int t = i.intValue();
int t = i;

数值类(byte,short,int,long,float,double)基本变量的包装类实现的方法

方法	含义
xxxValue()	将 Number 对象转换为xxx数据类型的值并返回。
compareTo()	将number对象与参数比较。
equals()	判断number对象是否与参数相等。
包装类.valueOf()	返回一个 Number 对象指定的内置数据类型
包装类.parseXXX()	静态方法，将字符串解析为XXX类。
toString()	以字符串形式返回值。

包装类转换为字符串类型：toString()
基本变量转换为字符串类型：+""
使用System.out.println(n);时会自动调用n对应类的toString方法

int n=Integer.parseInt("10");
System.out.println(n+"");
System.out.println(n);

Integer x = 5;
System.out.println(x.toString());
System.out.println(x);

非数值类(char，boolean)基本变量的包装类实现的方法

1.Character 方法

方法	含义
Character.isLetter()	是否是一个字母
Character.isDigit()	数字字符
Character.isWhitespace()	是否是一个空白字符
Character.isUpperCase()	是否是大写字母
Character.isLowerCase()	是否是小写字母
toString()	返回字符的字符串形式，字符串的长度仅为1

2.Boolean方法：没啥可说的

二、java字符串类String

java中： ’ '表示字符；" "表示字符串
python中：二者没有区别
java中：有三种类型可以存储字符串：

java中几种常用的字符串构造方法：

String greeting = "菜鸟教程";

//字符数组
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
String helloString = new String(helloArray);

连接字符串：

"Hello," + " runoob" + "!"

//concat方法
String s2 = ".....";
String s1 = "菜鸟教程";
s1.concat(s2);

创建格式化字符串

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

String 方法

方法	说明
char charAt(int index)	返回第idx个字符
int compareTo(Object o)	把这个字符串和另一个对象比较
int compareTo(String anotherString)	按字典顺序比较两个字符串。
int compareToIgnoreCase(String str)	按字典顺序比较两个字符串，不考虑大小写。
boolean contentEquals(StringBuffer sb)	当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
int indexOf(String str)	返回指定子字符串在此字符串中第一次出现处的索引。
int lastIndexOf(int ch)	返回指定字符在此字符串中最后一次出现处的索引。
int length()	返回此字符串的长度。
boolean matches(String regex)	告知此字符串是否匹配给定的正则表达式。
String replace(char oldChar, char newChar)	返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replaceAll(String regex, String replacement)	使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String[] split(String regex)	根据给定正则表达式的匹配拆分此字符串。
String substring(int beginIndex)	返回一个新的字符串，它是此字符串的一个子字符串。
String substring(int beginIndex, int endIndex)	它是此字符串的一个子字符串。
String trim()	返回字符串的副本，忽略前导空白和尾部空白。
String toUpperCase()	使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

分割操作

 String s="1,2,3,4,8,9";
 String[] ssp=s.split(",");
 for (int i=0;i<ssp.length;i++){
            System.out.print(ssp[i]);
        }

切片操作

String s1="abcdefghij";
System.out.println(s1.substring(0,5));

三、Java StringBuffer 和 StringBuilder 类

StringBuffer和StringBuilder 更适合于可变的字符存储

StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");
sBuffer.append("www");
sBuffer.append(".runoob");
sBuffer.append(".com");
System.out.println(sBuffer);

StringBuffer 方法：由于可变所以支持逆序，追加，插入，删除等操作；注意使用后用toString()方法转换为字符串

方法	说明
StringBuffer append(String s)	字符串追加到此字符序列
StringBuffer reverse()	将此字符序列用其反转形式取代。
delete(int start, int end)	移除此序列的子字符串中的字符。
insert(int offset, int i)	将 int 参数的字符串表示形式插入此序列中。
replace(int start, int end, String str)	使用给定 String 中的字符替换此序列的子字符串中的字符。
String substring(int start, int end)	返回一个新的 String，它包含此序列当前所包含的字符子序列。
String toString()	返回此序列中数据的字符串表示形式。

其余与String方法类似

        StringBuffer sb=new StringBuffer();
        sb.append('a');
        sb.append('b');
        sb.append('c');

        System.out.println(sb);
        System.out.println(sb.reverse());

四、IO、Stream、Sancer实现键盘输入

主要讲解从控制台输入，把输入的字符串解析为基本类型或者容器

1.使用BufferedReader

BufferedReader br = new BufferedReader(new InputStreamReader(System.in))

注意抛异常
可以read（）读取一个字符，br.readLine()读取一行

public class BRRead {
    public static void main(String args[]) throws IOException {
    	char c;
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        c = (char) br.read();

public class BRRead {
    public static void main(String args[]) throws IOException {
    	String str;;
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        str = br.readLine();

2.使用Scaner类

使用next() 与 nextLine() 方法获取输入的字符串
使用 hasNext 与 hasNextLine 判断是否还有输入的数据

next() ：

一定要读取到有效字符后才可以结束输入。
对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

nextLine() ：

以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白。

public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
        // 判断是否还有输入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("输入的数据为：" + str1);
        }
        scan.close();
    }

3.结合Stream和map实现输入整体入容器

将Scaner获取的String切分后转换为Stream，采用map转换为数值之后存入容器

python：

lst=list(map(int,input().split(" ")))

java:

Scanner sc=new Scanner(System.in);
String[] ss=sc.nextLine().split(" ");
List<Integer> r3 = Stream.of(ss).map(x->Integer.parseInt(x)).collect(Collectors.toList());

//
List<Integer> r3 = Stream.of(ss).map(Integer::parseInt).collect(Collectors.toList());
System.out.println(r3);

五、数组与工具类Arrays

1.数组定义及初始化

定义

int[] a;
int[][] aa;

初始化

静态：直接分配初始

a=new int[]{1,2,3};
aa=new int[][]{{1,2,3},{1,2,3}};

动态：直接分配空间，系统默认分配初值

a=new int[5];
aa=new int[5][];aa1=new int[5][5];

定义时初始化

静态
int[] a = new int[]{1,5};
int[][] aa = new int[][]{{1,5},{1,1},{2,4},{8,5}};
简化版本
int[][] aa ={{1,5},{1,1},{2,4},{8,5}};


动态：
int[] a=new int[4];

2.数组使用：

遍历

for循环

for(int i=0;i<arr.length,i++){
	System.our.println(arr[i]);
}

for each,把数组中的值先传递给形参

for(int i:arr){
	System.our.println(i);
}

3.数组工具类Arrays：

方法	含义
fill()	数组赋值
sort()	排序
copyOf()	拷贝
binarySearch()	二分查找
asList()	转换为List
toString()	打印数组元素

填充数组：Arrays.fill(array, 5)：
5 5 5 5 5 
将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：
5 5 8 8 5 
对数组的第2个到第5个元素进行排序进行排序：Arrays.sort(intTest,2,6)：
15 78 5 22 29 32 17 34 
对整个数组进行排序：Arrays.sort(intTest)：
5 15 17 22 29 32 34 78 
比较数组元素是否相等:Arrays.equals(array, intTest):
false
克隆后数组元素是否相等:Arrays.equals(array, array1):
true
数组前两个元素位置颠倒结果是否相等:Arrays.equals(intTesta, intTestb):
false
元素12在testA中的位置：Arrays.binarySearch(testA, 12)：
2
元素9在testA中的位置：Arrays.binarySearch(testA, 9)：
-3
元素12在testA中0到3的位置：Arrays.binarySearch(testA, 0,3,12)：
2
元素12在testA中0到2的位置：Arrays.binarySearch(testA, 0,2,12)：
-3
[5, 5, 8, 8, 5]
copyOf方法截取的数组元素为：
5 5 8 8 
copyOfRange方法截取的数组元素为：
5 8 8 
toString方法打印数组元素：
[hello, how, are, you, !]
数组转换为list，打印结果为:
hello how are you !

六、容器/集合类

java的容器类定义的时候要具体指明模板参数，不如python的灵活

1.Collection接口方法（集合都有）

	功能
向后追加	add(x)
向后追加所有	addAll(Collection<? extends E> c)
删除所有	clear()
包含	contains(Object o)
返回迭代器	iterator()
移除指定元素	remove(Object o)
大小	size()
流	stream()
转换为数组	toArray() / toArray(T[] a)
判空	isEmpty()

2.List

功能	python	java
向后追加	append(x)	add(x)
插入	insert(idx,x)	add(idx,x)
移除下标idx元素,并返回	pop(idx) 默认idx=-1最后一个	remove(idx)默认idx=0
移除指定元素	remove(x)默认移除左边第一个	remove(Object)：如(Integer.valueOf(x));
取值	lst[idx]	get(idx)
赋值	lst[idx]=val	set(idx,val)

3 Queue（接口）

功能	python	java
入队	append(x)	add(x)
出队	pop(0)	poll()
队首元素	queue[0]	peek()

3.1 Deque（接口）–》ArrayDeque

功能	java
队尾入队	add()/addLast()
队头入队	addFirst()
获取队头元素	peekFirst()
获取队尾元素	peekLast()
队头元素出队	pollFirst()
队尾元素出队	pollLast()

4. Set

java包含(HashSet,LinkedHashSet,TreeSet)

功能	python	java
初始化	s=set()	Set<> s=new Hashset<>();
添加	add()	add()
s1交s2	s1 \| s2	result.clear(); result.addAll(set1); result.retainAll(set2);
s1并s2	s1 & s2	result.clear(); result.addAll(set1); result.removeAll(set2);
s1差s2	s1-s2	result.clear(); result.addAll(set1); result.addAll(set2);
取出	转化为列表 list(s)	使用迭代器 Iterator it = set.iterator(); while(it.hasNext()){ System.out.print(it.next() + " ");}

5. Map(java) /dict字典（python）

功能	python	java
初始化	dic={}	Map<> map=new HashMap<>();
根据key获取值	dic[key]	map.get(key)
添加key-value	dic[key] =value	map.put(key,value)
包含key	key in dic或者 key in dic.keys()	map.containsKey(key)
包含value	v in dic.values()	map.containsValue(V)
获取条目	dic.items()	map.entrySet()

6.集合工具类collections

作用	静态方法
添加	addAll(Collection
二分查找	binarySearch(List
拷贝	copy()
填充	fill(List<? super T> list, T obj)
从枚举返回列表	list(Enumeration e)
大小	max(Collection),min,
逆序	reverse()
排序	sort()
交换	swap(List<?> list, int i, int j)

7.数组工具类Arrays

作用	静态方法
转换为list	asList(T… a)
二分查找	binarySearch(int[] a, int key)
拷贝	copyOf(int[] original, int newLength)
排序	sort(float[] a)
转换为字符	toString(int[] a)

使用数组初始化List
ArrayList<Type> obj = new ArrayList<Type>(Arrays.asList(Object o1, Object o2, ..so on));
List<Integer> list=new ArrayList<>(Arrays.asList(1,2,3,4));

List转数组

int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();

7.集合排序

此处只针对集合元素为字符串和数值类型的集合
Java中对于数值类型和String实现了Comparable接口，重写了compareTo方法，因此可以比较。
连接：https://blog.csdn.net/qq_43437465/article/details/89437637

java对于简单排序都是ok的

List<Integer> list0 = new ArrayList<>();
Random random = new Random();
for(int i = 0; i<10;i++){
    list0.add(random.nextInt(100));

   //[2, 19, 44, 46, 61, 67, 68, 89, 91, 94]
}
System.out.println(list0);

Collections.sort(list0);
System.out.println(list0);

而对于python自带的多级排序输入为二维数组，java实现起来就比较麻烦了：

python多级排序

d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
l = sorted(d1, key=lambda x:(-x['score'], x['name']))
print(l)
//输出
//[{'name': 'alice', 'score': 38}, {'name': 'christ', 'score': 28}, {'name': 'darl', 'score': 28}, {'name': 'bob', 'score': 18}]

参见java多级排序：

对二维数组实现两级排序：

public class main {
    public static void main(String[] args){
        int [][]a = new int[][]{{1,5},{1,1},{2,4},{8,5}};
        Arrays.sort(a, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0]==o2[0]) return o1[1]-o2[1];
                return o1[0]-o2[0];
            }
        });
        for (int[] a1: a) {System.out.println(a1[0]+" "+a1[1]);
        }
    }
}

对自定义类实现多级排序
http://blog.sina.com.cn/s/blog_5a15b7d10102w46p.html
将员工按照级别工资工龄多级排序

public Class Employee {  
   
    public int level;  //级别  
    public int salary; //工资  
    public int years;  //入职年数 
}

package net.oschina.tester;  
   
import java.util.ArrayList;  
import java.util.Collections;  
import java.util.Comparator;  
import java.util.List;  
   
  
public class Employee {  
   
    public static void main(String[] args) {  
        List objs = new ArrayList(){{  
            add(new Employee(5,3,5000,2));  
            add(new Employee(1,9,10000,10));  
            add(new Employee(4,5,8000,6));  
            add(new Employee(2,9,12000,7));  
            add(new Employee(6,1,2000,1));  
            add(new Employee(3,5,8000,12));  
        }};  
        Collections.sort(objs, comparator);  
        System.out.println("No\tLevel\tSalary\tYears\n=============================");  
        for(Employee a : objs)  
            System.out.printf("%d\t%d\t%d\t%d\n",a.id,a.level,a.salary,a.year);  
    }  
   
    public Employee(int id, int level, int salary, int year){  
        this.id = id;  
        this.level = level;  
        this.salary = salary;  
        this.year = year;  
    }  
       
    public int id;  
    public int level;  
    public int salary;  
    public int year;  
   
    private final static Comparator comparator = new Comparator(){  
        @Override  
        public int compare(Employee a1, Employee a2) {  
            int cr = 0;  
            int a = a2.level - a1.level;  
            if(a != 0)  
                cr = (a>0)?3:-1;  
            else{  
                a = a2.salary - a1.salary;  
                if(a != 0)  
                    cr = (a>0)?2:-2;  
                else{  
                    a = (int)(a2.year - a1.year);  
                    if(a != 0)  
                        cr = (a>0)?1:-3;  
                }  
            }  
            return cr;  
        }         
    };  
       
}

七、java8新特性 ——Stream

对于python来说，既没有8大基本类型及其包装类的转换，还能支持函数式编程、lambda编程，可以说是非常方便，如sort，max，sum等函数，以及fliter等

java8通过stream也支持了这些操作
参考
https://www.cnblogs.com/chenpi/p/5915364.html

Java中List, Integer[], int[]的相互转换

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class Main {
    public static void main(String[] args) {
        int[] data = {4, 5, 3, 6, 2, 5, 1};
 
        "int[] 转 List<Integer>"
        List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
        // Arrays.stream(arr) 可以替换成IntStream.of(arr)。
        // 1.使用Arrays.stream将int[]转换成IntStream。
        // 2.使用IntStream中的boxed()装箱。将IntStream转换成Stream<Integer>。
        // 3.使用Stream的collect()，将Stream<T>转换成List<T>，因此正是List<Integer>。
 
       "int[] 转 Integer[]"
        Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);
        // 前两步同上，此时是Stream<Integer>。
        // 然后使用Stream的toArray，传入IntFunction<A[]> generator。
        // 这样就可以返回Integer数组。
        // 不然默认是Object[]。
 
        "List<Integer> 转 Integer[]"
        Integer[] integers2 = list1.toArray(new Integer[0]);
        //  调用toArray。传入参数T[] a。这种用法是目前推荐的。
        // List<String>转String[]也同理。
 
        "List<Integer> 转 int[]"
        int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();
        // 想要转换成int[]类型，就得先转成IntStream。
        // 这里就通过mapToInt()把Stream<Integer>调用Integer::valueOf来转成IntStream
        // 而IntStream中默认toArray()转成int[]。
 
        "Integer[] 转 int[]"
        int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();
        // 思路同上。先将Integer[]转成Stream<Integer>，再转成IntStream。
 
        "Integer[] 转 List<Integer>"
        List<Integer> list2 = Arrays.asList(integers1);
        // 最简单的方式。String[]转List<String>也同理。
 
        // 同理
        String[] strings1 = {"a", "b", "c"};
        // String[] 转 List<String>
        List<String> list3 = Arrays.asList(strings1);
        // List<String> 转 String[]
        String[] strings2 = list3.toArray(new String[0]);
 
    }
}

八、python math和java Math

从实现的功能来说，python要比java强大很多

功能	java	python
三角函数	√	√
常量pi,e	√	√
数值舍取	round(),ceil(),floor()	round()不在math包中默认就有
最大最小绝对值	√（max和min两个参数）	√
sqrt()	√	√
对数	log():自然底数e log10()	log2() log(x,y=e) log10()
最大公约数	-	gcd(a,b)
n！	-	factorial(n)
范数	-	hypot(x,y)

注意
java

gcd可以采用辗转相除法计算

def gcd(a,b):
    if a%b == 0:
        return b
    else :
        return gcd(b,a%b)

任意底的对数，可以使用换底公式实现

python

阶乘factorial(n)要比自身实现快

算法题python容器方法对应的Java容器方法

算法题python容器方法对应的Java容器方法

一、java基本数据类型

二、java字符串类String

三、Java StringBuffer 和 StringBuilder 类

四、IO、Stream、Sancer实现键盘输入

1.使用BufferedReader

2.使用Scaner类

3.结合Stream和map实现输入整体入容器

五、数组与工具类Arrays

1.数组定义及初始化

2.数组使用：

3.数组工具类Arrays：

六、容器/集合类

1.Collection接口方法（集合都有）

2.List

3 Queue（接口）

3.1 Deque（接口）–》ArrayDeque

4. Set

5. Map(java) /dict字典（python）

6.集合工具类collections

7.数组工具类Arrays

7.集合排序

七、java8新特性 ——Stream

八、python math和java Math

杭州的 IT 崩盘了么？

开源高性能结构化日志模块NanoLog

Python 潮流周刊#55：分享 9 个高质量的技术类信息源！

Azure Virtual Network (22) 多订阅使用Azure DNS解析问题 Windows Azure Platform 系列文章目录

【简写Mybatis-02】注册机的实现以及SqlSession处理

手绘二维码

.NET借助虚拟网卡实现一个简单异地组网工具

win10編譯PCL cuda部分源碼並安裝：cmake3.10+vs2015+pcl1.8.1+cuda8.0GA2

meshlab常用功能

安卓學習筆記4——簡易新聞客戶端

算法題python容器方法對應的Java容器方法

安裝Ctex導致系統path路徑覆蓋

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結