Herranz
docencia research kt ¡colabora! blog

Programación 2

Curso 2024-2025

Una gran parte del código elaborado en clase se puede encontrar en el siguiente repositorio Git: https://gitlab.com/aherranz/p2-live

Transparencias, hojas de ejercicios y mini-laboratorios:

Curso 2023-2024

Una gran parte del código elaborado en clase se puede encontrar en el siguiente repositorio Git: https://gitlab.com/aherranz/p2-live

Transparencias y hojas de ejercicios:

Cursos anteriores

Curso 2022-2023

Una gran parte del código elaborado en clase se puede encontrar en el siguiente repositorio Git: https://gitlab.com/aherranz/p2-live

Transparencias y hojas de ejercicios:

Curso 2021-2022

Transparencias y hojas de ejercicios:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public interface IList<T> {
  void add(int index, T elem);
  T get(int index);
  int size();
  void set(int index, T elem);
  int indexOf(T elem);
  void remove(int index);
  void remove(T elem);
  IList<T> subList(int start, int end);
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

public class IListTest {
  private static final int N = 5;

  public static void main(String[] args) {
    IList<String> l = new ArrayList<String>();

    System.err.println(l);

    assert l.size() == 0;

    for (int i = 0; i < N; i++) {
      l.add(l.size(), "D" + i);
    }

    System.err.println(l);

    assert "[\"D0\", \"D1\", \"D2\", \"D3\", \"D4\"]"
      .equals(l.toString());

    assert "D3".equals(l.get(3));

    assert l.indexOf("D2") == 2;

    System.err.println(l.indexOf("XXX"));

    assert l.indexOf("XXX") == -1;

    assert new ArrayList<String>().indexOf("Hola") == -1;

    assert l.size() == N;

    assert l.indexOf("NO ESTA EN LA LISTA") == -1;

    l.remove(2);

    l.remove("D3");

    l.add(l.size(), "D4");

    System.err.println(l);

    assert l.indexOf("D4") == 2;

    l.remove("D4");

    assert l.size() == 2;

    l = new ArrayList<String>();
    for (int i = 0; i < N; i++) {
      l.add(0, "X"+i);
    }

    System.err.println(l);

    l.set(3, "TRES");

    assert l.size() == N;

    System.err.println(l);

    assert l.get(3).equals("TRES");

    for (int i = 0; i < N; i++) {
      if (i != 3)
        assert l.get(i).equals("X"+(N-i-1));
    }

    IList<String> subl = l.subList(1,3);

    assert subl.size() == 3;

    assert l.size() == N;

    System.err.println(l);
    System.err.println(subl);

    l = new ArrayList<String>();
    for (int i = 0; i < N; i++) {
      l.add(l.size(), "M"+i);
    }

    System.err.println(l);

    l.add(N/2, "MEDIO");

    System.err.println(l);

    assert l.size() == N + 1;

    for (int i = 0; i < N/2; i++) {
      assert l.get(i).equals("M"+i);
    }

    assert l.get(N/2).equals("MEDIO");

    for (int i = 1 + N/2 ; i < N + 1; i++) {
      assert l.get(i).equals("M"+(i-1));
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class IListTestVelocidad {
private static final int N = 100000;

public static void main(String[] args) {
  IList<String> l = new ArrayList<String>();

  for (int i = 0; i < N; i++) {
    l.add(i, "Hola");
  }
}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

public class ArrayList<T> implements IList<T> {
private final static int REDIM = 1000;
private Object[] data;
private int ultimo;

public ArrayList() {
  data = new Object[0];
  ultimo = -1;
}


private void redimensionar(int n) {
    Object[] aux = new Object[data.length + n];
    for (int j = 0; j <= ultimo; j++) {
      aux[j] = data[j];
    }
    data = aux;
}

public void add(int index, T elem) {
  if (ultimo == data.length - 1) {
    redimensionar(REDIM);
  }
  for (int i = ultimo; i >= index; i--) {
    data[i+1] = data[i];
  }
  data[index] = elem;
  ultimo++;
}

@SuppressWarnings("unchecked")
public T get(int index) {
  return (T)data[index];
}

public int size() {
  return ultimo + 1;
}

public void set(int index, T elem) {
  data[index] = elem;
}

public int indexOf(T elem) {
  int index = 0;
  while (index <= ultimo && !data[index].equals(elem))
    index++;
  if (index == ultimo + 1)
    index = -1;
  return index;
}

public void remove(int index) {
  for (int j = index; j < ultimo; j++) {
    data[j] = data[j+1];
  }
  ultimo--;

  if (ultimo == data.length - REDIM) {
    redimensionar(-REDIM/2);
  }
}

public void remove(T elem) {
  int index = indexOf(elem);
  while (index != -1) {
    remove(index);
    index = indexOf(elem);
  }
}

public IList<T> subList(int start, int end) {
  IList<T> sublist = new ArrayList<T>();
  int contador = 0;
  for (int i = start; i <= end; i++) {
    sublist.add(contador,get(i));
    contador++;
  }
  return sublist;
}

public String toString() {
  if (ultimo == -1) {
    return "[]";
  }
  else {
    String result = "[";
    for (int i = 0; i <= ultimo - 1; i++) {
      result += data[i] + ", ";
    }
    result += data[ultimo] + "]";
    return result;
  }
}
}

Curso 2020-2021

Estos vídeos sólo están accesibles para estudiantes de la UPM. Si estás interesado en acceder a ellos, por favor contacta conmigo.

Transparencias y hojas de ejercicios:

contact
© 2023 Ángel Herranz