1、Hello world

java：

public class HelloWorld{

    public static void main(String args[]){

        System.out.println("Hello world!");

    }

}

python:

print("Hello world!");

2、行代码标记结束

java:

System.out.println("Hello world!");

python:

print("Hello world")

java是以分号;来标记结束，而python则是以换行来作为标记，当然，python也可以添加分号在语句的末尾，但是一般不推荐

3、代码块

java

if(true){

    System.out.println("Hello world!");
    System.out.println("Hello world,agin!");

}

python

if True:
    print("Hello world!");
    print("Hello world, agin!");

java是以花括号{}来标记代码块逻辑层次，而python则是以tab键缩进来标记代码块的逻辑层次。

4、注释

Java

/**
 *  这是一个文本注释，
 *  当然，文本注释也是可以多行的
*/
public static void main(String args[]){

        //这是一个行注释
        System.out.println("以上是一个行注释");

        /*
            这是第一行注释
            这是第二行注释
        */
        System.out.println("以上是一个多行注释");
}    

python

def test():
    '''   
            这是一个多行注释的第一行
            这是一个多行注释的第二行
    '''
    print("以上是一个多行注释方式1")


    """ 
            这是一个多行注释的第一行
            这是一个多行注释的第二行
    """
    print("以上是一个多行注释的方式2")
  

    #这是一个行注释
    print("以上是一个行注释")


    #这是第一行注释
    #这是第二行注释
    print("以上是一个多行注释方式3")

5、标识符

python和java所有组成部分都需要名字：变量，函数...姑且都统称他们作标识符好了。

Java

• 所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始
• 首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合
• 关键字不能用作标识符
• 标识符是大小写敏感的

Python:

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 关键字不能用作标识符
  
• 标识符对大小写敏感。

不同之处在于，java可以包含$字符。

6、基本常用数据类型

6.1、基本数字类型

java

public static void main(String args[]){

    byte b = 100; //整数类型，占用空间只有int的1/4，8位

    short s = 1000; //整数类型，占用空间只有int的1/2，16位

    int i = 100000; //整数类型，32位

    Long l = 100000L; //整数类型，64位

    float f = 123.5f; //单精度浮点类型，32位

    double d = 123.5; //双精度浮点类型，64位

}

python

i = 10 # 整数
 
f = 0.0 #浮点数

c = 3.14j #复数

java中有6中数字类型，python中只有4种，但是python支持复数，而java则不支持。

上面提到了python中的数字类型，但是其实还有一种：布尔类型。这里单独放到下面举例。

6.2、布尔类型

java

boolean b = false; //只有两种可能，true 或者false

python

b = False #注意，这里的F是大写的，python3中，布尔类型也是一种数字类型，False可以是数字0，True可以是数字1

6.3、字符类型/字符串类型

java

public static void main(String args[]){

        char c1 = 'a'; //java中，字符为基本类型，这里的c1指代任意一个在ASCII编码表中的字符,用单引号括起来

        System.out.println("打印一个字符："+c1);

        chat c2 = 111; //这里的c2指代在ASCII编码表中索引为111的字符，即a

        System.out.println("打印一个字符数值在ASCII编码表中对应的字符："+ c2); //

        String str = "Hello world!"; //java中，字符串并非基本类型，而是属于引用类型，表示多个字符拼接在一起

        System.out.println("打印一串字符："+str);

}

python

str1 = 'Hello world!' #字符串定义方式1

str 2 = "Hello world!"; # 字符串定义方式2

python中没有字符类型，只有字符串类型，并且字符串类型是python的基本类型之一。

6.4、List（列表）

java

int array[] = {1,2,3,4}; //方式1：定长数组

array[0] = -1;            //修改数组第0个元素的值

System.out.println("第一个值为："+array[0]);
System.out.println("数组长度为："+array.length);

list = new ArrayList(); //方式2：可变列表
list.add(1);
list.add(2);
list.add(3);
list.add(4);             //设置初始化值

list.set(0,-1);          //修改第0个元素的值

System.out.println("第一个值为："+list.get(0));
System.out.println("列表长度为："+list.size());

python

list1 = ['Google', 'Runoob', 1997, 2000] #列表1,同时参杂字符串 和 数字

list2 = [1, 2, 3, 4, 5 ]                 #列表2,只包含数字

list3 = ["a", "b", "c", "d"]             #列表3,只包含字符串

list1[0] = 'Nemo'

list1.append('Hello')                    #往列表最后新增一个元素

print('第一个值为：%s'%(list1[0]))

print('列表长度为：%d'%(len(list1)))

for item in list1:

    print('遍历打印：%s'%(item))

可以看到，java的数组、列表与python的列表都有相似之处：

1、都是属于有序列表。

2、索引都是从0开始。

3、里面的值都可以修改。

不同的地方大概就在于

1、java数组是定长的，并且元素类型一般一致（Object泛型除外）。

2、java列表是可变长度的，并且元素类型一般一致（Object泛型除外）。

3、python列表是可变长度，并且里面的元素类型不需要一致。

6.5、Tuple（元组）

java中与python元组类似的也就是列表和数组，关于java中的列表和数组以上已做过说明，此处暂且略去。

python

tup1 = ('Google', 'Runoob', 1997, 2000) #元组1,同时参杂字符串 和 数字

tup2 = (1, 2, 3, 4, 5)                  #元组2,只包含数字

tup3 = ("a", "b", "c", "d")             #元组3,只包含字符串

#tup1[0] = 'Nemo'                       #此操作会导致异常

#tup1.append('Hello')                   #往元组最后新增一个元素  #异常

print('第一个值为：%s'%(tup1[0]))

print('列表长度为：%d'%(len(tup1)))

for item in tup1:

    print('遍历打印：%s'%(item))

可以看到，python中的元组和列表其实非常类似的，区别之处就在于：

元组元素不可以修改，而列表可以。

所以总结下来java中，列表、数组与python中的元组的区别就在于：

1、都是属于有序列表。

2、索引都是从0开始。

不同的地方大概就在于：

1、java数组是定长的，并且元素类型一般一致（Object泛型除外）。

2、java列表是可变长度的，并且元素类型一般一致（Object泛型除外）。

3、python元组是定长的，并且里面的元素类型不需要一致，且元素不可修改。

6.6、Set（集合）

java

//这里只用HashSet做说明，TreeSet不做涉及
Set set = new HashSet();

set.add("Nemo");
set.add("Nemo");
set.add("Kira");
set.add("1");
set.add("2");

System.out.println("集合长度 ：" + set.size());  //输出： 

for(String val : set){
    System.out.println("值输出："+val);
}

（某次）最终输出：

集合长度：4
值输出：1
值输出：2
值输出：Nemo
值输出：Kira

python：

bus = {'Nemo','Kira',1,2,'Nemo'}
bus.add('Nemo')
print('集合长度：%d'%(len(bus)))
for item in bus:
    print('值输出%s'%(item))

（某次）最终输出：

集合长度：4
值输出：1
值输出：2
值输出：Nemo
值输出：Kira

可以看到，java中的集合跟python中的集合是非常类似的。

1、元素都不可重复。

2、元素都无序。

不同之处在于：

1、python的集合里面的元素类型可以不一致，而java中则一般一致（Object泛型除外）。

6.7、Dictionary（字典）

java

//这里只用HashMap作为说明
Map map = new HashMap;
map.put("name","Nemo");
map.put("name","Kira");
map.put("age","Nemo");
map.put("age","17");

System.out.println("字典长度："+map.size());

for(String key : map.keySet()){
    System.out.println("键："+key + " - 值："+map.get(key));
}

最终输出：

字典长度：2

键：name - 值：Kira
键：age - 值：17

python

dict = {'name':'Nemo','age':17}

dict['name'] = 'Kira'

print('字典长度：%d'%(len(dict)))

for (key,val) in dict.items():
    print('键：%s - 值：%s'%(key,val))

最终输出：

字典长度：2
键：name - 值：Kira
键：age - 值：17

7、运算符

7.1、算术运算符

java

+（加法）、-（减法）、*（乘法）、/（除法）、%（取余）、++（自增1）、--（自减1）

python

+（加法）、-（减法）、*（乘法）、/（除法）、%（取余）、**（幂）、//（取整除）

7.2、关系运算符

java

== 检查两个操作数是否相等
!= 检查两个操作数是否不相等
>  检查左边的操作数是否大于右边的操作数
<  检查左边的操作数是否小于右边的操作数
>= 检查左边的操作数是否大于或者等于右边的操作数
<= 检查左边的操作数是否小于或者等于右边的操作数

python同java。

7.3、位运算符

java

&  按位与运算符
|  按位或运算符
^  按位异或运算符
~  按位取反运算符
<< 按位左移运算符
>> 按位右移运算符
>>>按位右移补零操作符

python

&  按位与运算符
|  按位或运算符
^  按位异或运算符
~  按位取反运算符
<< 按位左移运算符
>> 按位右移运算符

python较java少按位右移补零操作符。

7.4、逻辑运算符

java

&& 逻辑与运算符
|| 逻辑或操作符
!  逻辑非运算符

python

and 逻辑与运算符
or  逻辑或运算符
not 逻辑非运算符

7.5、赋值预算符

java

=   简单的赋值运算符
+=  加和赋值操作符
-=  减和赋值操作符
*=  乘和赋值操作符
/=  除和赋值操作符
(%)=取模和赋值操作符
<<= 左移位赋值运算符
>>= 右移位赋值运算符
&=  按位与赋值运算符
^=  按位异或赋值操作符
|=  按位或赋值操作符

python

=   简单的赋值运算符
+=  加法赋值运算符
-=  减法赋值运算符
*=  乘法赋值运算符
/=  除法赋值运算符
%=  取模赋值运算符
**= 幂赋值运算符
//= 取整除赋值运算符

8、条件控制

java:

public class Test {
   public static void main(String args[]){
      int x = 30;
      if( x == 10 ){
         System.out.print("Value of X is 10");
      }else if( x == 20 ){
         System.out.print("Value of X is 20");
      }else if( x == 30 ){
         System.out.print("Value of X is 30");
      }else{
         System.out.print("这是 else 语句");
      }
   }
}

python

x = 30
if x == 10:
    print('Value of x is 10')
elif x == 20:
    print('Value of x is 20')
elif x == 30:
    print('Value of x is 30')
else:
    print('这是 else 语句')

9、循环控制

9.1、while/do...while/while...else

java：

//java:while 
public class Test {
   public static void main(String args[]) {
      int x = 10;
      while( x < 20 ) {
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }
   }
}

python：

# python: while
x = 10
while x < 20:
    print('Value of x:%d'%x)
    x = x + 1

java:

// java: do...while
public class Test {
   public static void main(String args[]){
      int x = 10;
      do{
         System.out.print("value of x : " + x );
         x++;
      }while( x < 20 );
   }
}

python:

# python: while...else
x = 10 
while x < 20:   
    print('value of x : %d',x)
    x = x + 1
else:
    print(' else ')

9.2、for

java:

public class Test {
   public static void main(String args[]) {
      //普通for：
      for(int x = 10; x < 20; x = x+1) {
         System.out.println("value of x : " + x );
      }

      //增强for：
      int numbers = {10,20,30,40,50};
      for(int x : numnbers){
             if(x == 20){
                continue;
             }
             if(x == 40){
                 break;
             }
            System.out.println("value of x : " + x);
      }
   }
}

python:

numbers = [10,20,30,40,50]
for x in numbers:
    if x == 20:
        continue
    if x == 40:
        break
    print('value of x : %d'%x)

10、函数/方法

基本语法：
修饰符 返回值类型 方法名(参数类型 参数名, 参数类型 参数名){
    // 方法体
    return 返回值;
}


public class MyClass{

    //ex 1:
    public static int sum(int num1,int num2){
        int result = num1 + num2;
        return result;
    }

    //ex 2:
    public void stdout(int sum){
        System.out.println("The sum is:" + sum);
    }

    //ex 3:
    public void stdlog(){
        System.out.println("Log is here");
    }


    // call
    public static void main(String[]args){
        MyClass myClass = new MyClass();
        //call ex1:
        int num1 = 100;
        int num2 = 200;
        int sum = myClass.sum(num1, num2);

        // call ex2:
        myClass.stdout(sum);

        // call ex3
        myClass.stdlog();
    }
}

Python

基本语法：
def 方法名(参数列表):
    # 方法体
    return 返回值1, 返回值2

# ex1
def sum(num1, num2):
    return num1 + num2


# ex2
def stdout(sum):
    print('The sum is: ' + str(sum))


# ex3
def stdlog():
    print('Log is here"')


// call
num1 = 100
num2 = 200
sum = sum(num1, num2)
stdout(sum)
stdlog()