JAVA |
PYTHON |
Java is a statically
typed language. Python is much better suited as a “glue” language.
|
Python is a
dynamically typed language. Java is better characterized as a low low-level
implementation language.
|
Requires to define
the type of each variable, it’s object oriented in the sense that you can’t
write any code without defining a class. You also invoke a compiler the code –
then you can run it.
|
No requires to
declare any variables. You can mix object-oriented and imperative
programming. You run the code directly.
|
Run faster than Python.
|
Slower than Java.
|
JAVA VS PYTHON BY COMPARING “HELLO WORLD” |
|
Hello world in Java:
Public class Main
{
Public static void main(String
[] args)
{
System.out.println(“hello
world”);
}
}
|
Hello world in
Python:
Print “hello world”;
|
JAVA VS PYTHON BY COMPARING “SIMPLE CODE EXAMPLES” |
|
String operations in
Java:
Public static void
main(String [] args)
{
String test=”compare Java with
Python”;
for(String a : test.split(“
“))
System.out.println(a);
}
|
String operations in
Python:
A=”compare Python
with Java”;
Print a.split();
|
JAVA VS PYTHON BY COMPARING “CONTROL FLOW” |
|
Control flow in Java:
int condition=10;
//if
If(condition>10)
System.out.println(“>10”);
else
System.out.println(“<10”);
//while
while(condition>1){
System.out.println(condition);
Condition--;
}
//switch
switch(condition){
case 1:
System.out.println(“is
1”);
break;
case 2:
System.out.println(“is
2”);
break;
}
//for
for(int
i=0;i<10;i++){
System.out.println(1);
}
|
Control flow in
Python:
# if
if condition >
10;
print “>10”;
elif condition ==10;
print”=10”;
else:
print”<10”;
# while
while condition >
1;
print condition;
condition= condition-1;
# switch
def f(x):
return {
1 : 1,
2 : 2,
}[x]
print f(condition);
# for
for x in
range(1,10):
print x;
|
JAVA VS PYTHON BY COMPARING “CLASS AND INHERITANCE” |
|
Class &
Inheritance in Java:
class Animal{
private String name;
public Animal(String name){
this.name=name;
}
}
class Dog extends
Animal{
public Dog(String name){
super(name);
}
}
public class Main {
public static void
main(String[] args)
{
Dog dog=new
Dog("Chiwawa");
dog.saySomething();
}
}
|
Class &
Inheritance in Python:
Class Animal():
def __init__(self, name):
self.name=name
def saySomething(self):
print "I
am " + self.name
class Dog(Animal):
def saySomething(self):
print "I
am " + self.name\+ ", and I can bark"
dog=DOg("Chiwawa")
dog.saySomething()
|
JAVA VS PYTHON BY COMPARING “FILE I/O” |
|
File I/O in Java:
// get current
directory
File dir = new
File(".");
File fin = new
File(dir.getCannonicalPath() + File.seperator + "Code.txt");
FileInputStream fis
= new FileInputStream(fin);
// Construct the
BufferedReader object
BufferedReader in =
new BufferedReader(new InputStreamReader(fis));
String aLine = null;
while ((aLine =
in.readline()) != null)
{//Process each
line, here we count empty lines
if(aLine.trim().length()==0){
}
}
//Do not forget to
close the buffer reader
in.close();
|
File I/O in Python:
myFile =
open("/home/xiaoran/Desktop/test.txt")
print myFile.read();
|
JAVA VS PYTHON BY COMPARING “COLLECTIONS” |
|
Collections in Java:
import
java.util.ArrayList;
public class Main{
public static void
main(String[] args)
{
ArrayList<String>
a1=new ArrayList<String>();
a1.add("a");
a1.add("b");
a1.add("c");
System.out.println(a1);
}
}
|
Collections in
Python:
aList=[]
aList.append("a");
aList.append("b");
aList.append("c");
print aList;
|
JAVA VS PYTHON BY COMPARING “NUMBERS” |
|
Numbers in Java:
//Integer numbers
int num = 100;
//Floating point
numbers
float f = 1.01f;
//float f =
1.01;//Wrong!
double d = 1.01;
|
Numbers in Python:
# Integer numbers:
num = 100
num =
int("100")
# Floating point
numbers
f = 1.01
f =
float("1.01")
# null
spcial = None
|
JAVA VS PYTHON BY COMPARING "NULL" |
|
Null in Java:
//null
object special =
null;
|
Null in Python:
# null
spcial = None
|
JAVA VS PYTHON BY COMPARING "TUPLES" |
|
Tuples in Java:
No tuples in Java.
|
Tuples in Python:
aTuple = ()
aTuple = (5) # cause
error
aTuple = (5,)
print aTuple
print aTuple
#5
|
JAVA VS PYTHON BY COMPARING "SETS" |
|
Sets in Java:
//Hashset
HashSet<String<
aSet = new HashSet<String>();
aSet.add("aaaa");
aSet.add("bbbb");
aSet.add("cccc");
aSet.add("dddd");
//Iterate over set
Iterator<String>.iterator
= aSet.iterator();
while
(iterator.hasNext()){
System.out.println(iterator.next()
+ " ");
}
HashSet<String>
bSet = new HashSet<String>();
bSet.add("eeee");
bSet.add("ffff");
bSet.add("gggg");
bSet.add("dddd");
//Check if bSet is a
subset of aSet
boolean b =
aSet.ContainsAll(bSet);
//Union - transform
aSet
//into the union of
aSet and bSet
aSet.addAll(bSet);
//intersection -
transform aSet
//into the
intersection of aSet and bSet
aSet.retainAll(bSet);
//difference -
transforms aSet
//into the
(asymmetric) set difference
// of aSet and bSet.
aSet.removeAll(bSet);
|
Sets in Python:
aSet = set()
aSet =
set("one") #a set containing three letters
#Set(['e', 'o',
'n'])
aSet = set(['one',
'two', 'three'])
#set(['three',
'two', 'one'])
#a set containing
three words
#iterate over set
for v in aSet:
print v
bSet = set(['three',
'four', 'five'])
#union
cSet = aSet | bSet
#intersection
dSet = aSet &
bSet
#find elements in
aSet not bSet
eSet =
aSet.difference(bSet)
#add element
bSet.add("six")
#set(['four', 'six',
'five', 'three'])
|
JAVA VS PYTHON BY COMPARING "DICTIONARIES" |
|
Dictonaries in Java:
HashMap<Sting,
String> phoneBook = new HashMap<String, String>();
phoneBook.put("Mike",
"555-1111");
phoneBook.put("Lucy",
"555-2222");
phoneBook.put("Mike",
"555-3333");
//iterate over
HashMap
Map<String,
String>map= new HashMap<String, String>();
for
(Map.Entry<String, String> entry; map.entrySet()){
System.out.println("Key
= " + entry.getKey() + ", Value = " + entry.getValue());
}
//get key value
phoneBook.get("Mike");
//get all key
Set keys =
phoneBook.keySet();
//get number of
elements
phoneBook.size();
//delete all
elements
phoneBook.clear();
//delete an element
phoneBook.remove("Lucy");
|
Dictonaries in
Python:
#create an empty
dictionary
phoneBook = {}
phoneBook =
{"Mike":"555-1111","Lucy":"555-2222","Jack":"555-3333"}
#iterate over dictionary
for key in
phoneBook:
print(key, phoneBook[key])
#add an element
phoneBook["Marry"]
= "5555-6666"
#delete an element
del
phoneBook["Mike"]
#get number of
elements
count =
len(phoneBook)
#can have different
types
phoneBook["SUsan"]
= (1, 2, 3, 4)
#return all keys
print
phoneBook.keys()
#delete all the
elements
phoneBook.clear()
|
No comments:
Post a Comment