Podstawowe typy danych

Typy prymitywne, tablice, łańcuchy znaków oraz typ wyliczeniowy


dr inż. Aleksander Smywiński-Pohl

apohllo@o2.pl

http://apohllo.pl/dydaktyka/obiektowe

Typy prymitywne

  • boolean - wartości true i false
  • char - pojedyncze znaki z zestawu Unicode
  • byte - jednobajtowa liczba ze znakiem
  • short - dwubajtowa liczba ze znakiem
  • int - czterobajtowa liczba ze znakiem
  • long - ośmiobajtowa liczba ze znakiem
  • float - liczba zmiennopozycyjna, co najmniej 6 cyfr znaczących
  • double - liczba zmiennopozyzyjna, co najmniej 15 cyfr znaczących

Typ boolean

In [ ]:
int invalidValue = 1;
if(invalidValue) {                                  
    System.out.println("Wycieraczki są włączone");
} else {
    System.out.println("Wycieraczki są wyłączone");
}
In [ ]:
boolean wipersOn = true;
if(wipersOn) {
    System.out.println("Wycieraczki są włączone");
} else {
    System.out.println("Wycieraczki są wyłączone");
}

Typ char

In [ ]:
import static java.lang.System.out;

char driverCategory = 'ś'
char tick = '\u2713'
out.println(driverCategory);
out.println(tick);
out.println(Character.isLetter(driverCategory));
out.println(Character.isLetter(tick));

Typy całkowitoliczbowe: byte, short, int oraz long

In [ ]:
int a = 10;
int b = 20;
long c = a + b;
short d = a + b;
short e = (short) (a + b);
In [ ]:
int a = 10;
int b = 20;
if(Short.MAX_VALUE > a + b){
    e = (short) (a + b);
}
byte f = 127;
byte g = 127;
byte h = (byte) (f + g);

Typy zmiennopozycyjne float i double

In [ ]:
import static java.lang.System.out;

int a = 0;
float b = 0.0f;

if(a == b){
    out.println("Wartości są identyczne");
}
In [ ]:
double EPSILON = 1e-5;
int a = 0;
float b = 0.0f;

if(Math.abs(a - b) < EPSILON){
    out.println("Wartości są prawie identyczne");
}
In [ ]:
float a = 0.0f;
float b = 0.001f;
for(int i=0; i < 1000; i++){
    a += b;
}
if(a == 1.0){
    out.println("Wartości są identyczne");
} else {
    out.println("Wartości nie są identyczne");
}

Typy otokowe

  • Boolean
  • Byte
  • Short
  • Character
  • Integer
  • Long
  • Float
  • Double

In [ ]:
Integer a = new Integer(10);
Integer b = new Integer(20);
Integer c = a + b;
out.println(c.toString());
In [ ]:
int d = 30;
out.println(d.toString());

Zastosowanie typów otokowych

In [ ]:
List<Integer> list = new LinkedList<Integer>();
list.add(new Integer(10));
list.add(new Integer(20));

out.println(list);
In [ ]:
// Autoboxing

List<Integer> list = new LinkedList<Integer>();

list.add(30);
list.add(40);

out.println(list);

Porównywanie typów otokowych

In [ ]:
Integer a = 200;
Integer b = 200;
if(a == b){ 
    out.println("Wartości są równe");
} else {
    out.println("Wartości nie są równe");
}
In [ ]:
Integer a = 200;
Integer b = 200;
if(a.equals(b)){ 
    out.println("Wartości są równe");
} else {
    out.println("Wartości nie są równe");
}

Typ tablicowy

In [ ]:
import static java.lang.System.out;

int[] speedVector = new int[3];
speedVector[0] = 10;
speedVector[2] = -3;

for(int i = 0; i < 4; i++){
    out.println("Składowa " + (i + 1) + " wektora wynosi: " + speedVector[i]);
}

Typ tablicowy - obiekty

In [ ]:
class Speed {
    public int value;
    public String unit;

    public Speed(int value, String unit){
        this.value = value;
        this.unit = unit;
    }
}

Typ tablicowy - obiekty

In [ ]:
import static java.lang.System.out;

Speed[] speedVector = new Speed[3];
speedVector[0] = new Speed(10, "km/h");
speedVector[1] = new Speed(-3, "km/h");

for(int i = 0; i < 3; i++){
    out.println("Składowa " + (i + 1) + " wektora wynosi: " + 
        speedVector[i].value + " " + speedVector[i].unit);
}

Zabezpieczenie przed wyjątkiem NullPointerException

In [ ]:
import static java.lang.System.out;

Speed[] speedVector = new Speed[3];
speedVector[0] = new Speed(10, "km/h");
speedVector[1] = new Speed(-3, "km/h");

for(int i = 0; i < 3; i++){
    if(speedVector[i] == null) {
        out.println("Składowa " + (i + 1) + " wektora jest pusta");
    } else {
        out.println("Składowa " + (i + 1) + " wektora wynosi: " + 
            speedVector[i].value + " " + speedVector[i].unit);
    }
}

Alternatywna pętla for

In [ ]:
import static java.lang.System.out;

Speed[] speedVector = new Speed[3];
speedVector[0] = new Speed(10, "km/h");
speedVector[1] = new Speed(-3, "km/h");

for(Speed element : speedVector){
    if(element == null) {
        out.println("Składowa wektora jest pusta");
    } else {
        out.println("Składowa wektora wynosi: " + 
            element.value + " " + element.unit);
    }
}

Porównywanie tablic

In [ ]:
import static java.lang.System.out;

int[] speedVector1 = { 10, -3, 0 };
int[] speedVector2 = { 10, -3, 0 };

if(speedVector1 == speedVector2){
    out.println("Wektory są równe");
} else {
    out.println("Wektory nie są równe");
}
In [ ]:
int[] speedVector1 = { 10, -3, 0 }
int[] speedVector2 = { 10, -3, 0 }
if(speedVector1.equals(speedVector2)){
    out.println("Wektory są równe");
} else {
    out.println("Wektory nie są równe");
}
In [ ]:
if(Arrays.equals(speedVector1, speedVector2)){
    out.println("Wektory są równe");
} else {
    out.println("Wektory nie są równe");
}

Sortowanie i wypisywanie tablic

In [ ]:
import static java.lang.System.out;

int[] vector = { 7, 15, 10, -3, 9, 12}
Arrays.sort(vector);
out.println(vector.toString());
out.println(Arrays.toString(vector));

Tablice wielowymiarowe

In [ ]:
int[][] matrix1 = new int[10][10];
out.println(matrix1[0][0]);
In [ ]:
int[][] matrix2 = new int[10][];
out.println(matrix2[0][0]);

for(int i = 0; i < 10; i++){
    matrix2[i] = new int[10];
}
out.println(matrix2[0][0]);

Porównywanie i wyświetlanie tablic wielowymiarowych

In [ ]:
import static java.lang.System.out;

int[][] matrix1 = { {1, 2}, 
                    {3, 4} };
int[][] matrix2 = { {1, 2}, 
                    {3, 4} }
               
out.println(Arrays.toString(matrix1));
In [ ]:
out.println(Arrays.deepToString(matrix1));
In [ ]:
if(Arrays.equals(matrix1,matrix2)){
    out.println("Tablice są równe");
} else {
    out.println("Tablice **nie** są równe");
}
In [ ]:
if(Arrays.deepEquals(matrix1,matrix2)){
    out.println("Tablice są równe");
} else {
    out.println("Tablice **nie** są równe");
}

Łańcuchy znaków

In [ ]:
import static java.lang.System.out;

String unit1 = "km/h";
String unit2 = "km/h";
String letter = "h";
String unit3 = "km/"  + letter;

if(unit1 == unit2){
    out.println("Jednostki są równe");
} else {
    out.println("Jednostki **nie** są równe");
}
In [ ]:
if(unit1 == unit3){
    out.println("Jednostki są równe");
} else {
    out.println("Jednostki **nie** są równe");
}
In [ ]:
if(unit1.equals(unit3)){
    out.println("Jednostki są równe");
} else {
    out.println("Jednostki **nie** są równe");
}

Modyfikacja łańcuchów

In [ ]:
import static java.lang.System.out;

String km = "km";
String divider = "/";
String hour = "h";

String unit1 = "";
String unit2 = unit1;
unit1 += km;
unit1 += divider;
unit1 += hour;
In [ ]:
if(unit1 != unit2){
    out.println("Łańcuchy nie są równe");
}
In [ ]:
import static java.lang.System.out;

String km = "km";
String divider = "/";
String hour = "h";

StringBuilder builder1 = new StringBuilder();
StringBuilder builder2 = builder1;
builder1.append(km);
builder1.append(divider);
builder1.append(hour);
In [ ]:
if(builder1 == builder2){
    out.println("Budowniczowie łańcuchów są równi");
}

builder1.toString();

Typ wyliczeniowy

In [ ]:
import static java.lang.System.out;

enum Color {
    Red,
    Green,
    Blue
}

Color carColor = Color.Green;
out.println(carColor.name());
out.println(carColor.ordinal());
out.println(Arrays.toString(Color.values()));

Instrukcja selekcji i typ wyliczeniowy

In [ ]:
import static java.lang.System.out;

Color carColor = Color.Green;

switch(carColor){
    case Red:
        out.println("Jesteś strażakiem?");
        break;
    case Green:
        out.println("Łatwo ukryć go w lesie");
        break;
    case Blue:
        out.println("Pracujesz w policji?");
        break;
}

Instrukcja selekcji i łańcuchy znaków

In [ ]:
String color = "red";

switch(color){
    case "red":
        out.println("Jesteś strażakiem?");
        break;
    case "green":
        out.println("Łatwo ukryć go w lesie");
        break;
    case "blue":
        out.println("Pracujesz w policji?");
        break;
}

Porównywanie wartości typu wyliczeniowego

In [ ]:
Color color1 = Color.Red;
Color color2 = Color.Red;

if(color1 == color2){
    out.println("Kolory są równe");
}

Typ logiczny w Rubim

In [ ]:
#!ruby
# encoding: utf-8

if(nil)
  puts "Nil jest prawdą"
else
  puts "Nil jest fałszem"
end
  
if(false)
  puts "Fałsz jest prawdą"
else
  puts "Fałsz jest fałszem"
end
In [ ]:
# encoding: utf-8

if(true)
  puts "Prawda jest prawdą"
end
  
if("false")
  puts "Łańcuch 'false' jest prawdą"
end
  
if(0)
  puts "Zero jest prawdą"
end
In [ ]:
puts(true.to_s)

Wartości liczbowe

In [ ]:
puts 100 ** 1000
In [ ]:
p 100 / 9
p 100 / 9.0
In [ ]:
10.times { puts "x" }
In [ ]:
p 10.to_s
In [ ]:
p "10".to_i
p "10".to_i(2)
In [ ]:
p 10 + 2 * 3
p 10.+(2.*(3))

Tablice

In [ ]:
a = [1,2,3]
p a[0]
p a[0..1]
p a[0...1]
p a[-2..-1]
In [ ]:
b = ["a", nil, 3]
puts b
p(b)
In [ ]:
c = [3, 7, 0, -10, 11, 1.1]
p(c.sort)
In [ ]:
d = Array.new(10, 1)
p(d)

Porównwanie wartości

In [ ]:
# encoding: utf-8

x = 100
y = 100

if(x == y)
  puts "Wartości liczbowe są sobie równe"
end
In [ ]:
# encoding: utf-8

a = "Ala"
b = "Ala"
if(a == b)
  puts "Łańcuchy są sobie równe"
end
In [ ]:
# encoding: utf-8

a = [1,2,3]
b = [1,2,3]

if(a == b)
  puts "Tablice są sobie równe"
end
In [ ]:
# encoding: utf-8

c = [
        [1,2,3],
        [2,3,4]
    ]
d = [
        [1,2,3],
        [2,3,4]
    ]

if(c == d)
  puts "Tablice wielowymiarowe są sobie równe"
end

Wartość pusta nil

In [ ]:
puts nil.nil?
puts 1.nil?
In [ ]:
# encoding: utf-8

a = nil

if(a.nil?)
  puts "Niepoprawna wartość"
end

p a.to_s

Pytania?