Esta página necesita un navegador reciente (con soporte para SharedArrayBuffer). Por favor, actualiza Chrome, Edge, Firefox o Safari a la última versión.
1Conceptos básicos de Java
1.1
Clases, método principal y salida
Este sitio compila Java usando las reglas del lenguaje Java 8. Estos ejemplos independientes colocan su método de entrada, main, dentro de una clase. Las clases auxiliares y respuestas solo de método no necesitan su propia main. System.out.println(...) imprime una línea; System.out.print(...) imprime sin salto de línea.
public class Main {
public static void main(String[] args) {
System.out.println("Hello, world!");
System.out.println("I am learning Java.");
}
}
Java se compila: el compilador revisa todo el programa y luego lo ejecuta.
Declarations, assignments, method calls and return statements end with a semicolon ;. An if, for or while block uses braces; do not add a semicolon just because its closing brace appears.
Este ejemplo independiente de Java 8 define main dentro de una clase
1.2
Variables y tipos primitivos
Una variable debe declarar su tipo. Tipos primitivos comunes: int (número entero), double (decimal), boolean (true/false), char (una unidad de código UTF-16; algunos caracteres requieren dos).
public class Main {
public static void main(String[] args) {
int age = 17;
double price = 9.99;
boolean passed = true;
System.out.println(age + " " + price + " " + passed);
}
}
1.3
Comentarios y estilo
Un comentario es // (una línea) o /* ... */ (un bloque). Indente el código dentro de las llaves { }. Los nombres de clase inician con mayúscula; variables y métodos usan camelCase (minúscula inicial).
public class Main {
public static void main(String[] args) {
// greet the user
String firstName = "Mei";
System.out.println("Hi, " + firstName);
}
}
Errores comunes
Las declaraciones, asignaciones, llamadas a métodos y sentencias return terminan con ;; los bloques de control de flujo no necesitan un punto y coma extra.
Use el punto de entrada estándar de Java 8 public static void main(String[] args); el nombre del parámetro puede variar, y String... args también es válido.
println añade un salto de línea; print no lo hace.
2Operadores y expresiones
2.1
Aritmética y asignación
La aritmética de Java 算术 usa + - * / y % (residuo). Con dos ints, / es división entera 整数除法 — elimina la parte decimal. +=, -= y ++ son atajos.
public class Main {
public static void main(String[] args) {
int a = 7, b = 2;
System.out.println(a / b); // 3 (integer division)
System.out.println(a % b); // 1
double x = 7.0 / 2; // 3.5 (one side is double)
System.out.println(x);
}
}
int/int truncará; involucre un double para obtener un cociente real
2.2
Usando objetos: String, Math, wrappers
Algunos valores son objetos 对象 con métodos. String tiene .length(), .substring(), .toUpperCase(). Math tiene Math.max, Math.sqrt, Math.pow. Las clases wrapper 包装类 (Integer, Double) envuelven un primitivo — por ejemplo, Integer.parseInt("42").
public class Main {
public static void main(String[] args) {
String s = "Hello";
System.out.println(s.length()); // 5
System.out.println(s.toUpperCase()); // HELLO
System.out.println(Math.max(3, 9)); // 9
System.out.println(Integer.parseInt("42") + 1); // 43
}
}
Math.random() devuelve un aleatorio 随机 double desde 0.0 hasta (sin incluir) 1.0. Escálalo y conviértelo para obtener números enteros — esta es la idiomática AP:
public class Main {
public static void main(String[] args) {
// a random whole number from 1 to 6 (a dice roll)
int roll = (int) (Math.random() * 6) + 1;
System.out.println(roll >= 1 && roll <= 6); // true
}
}
Integer.MAX_VALUE (2147483647) y Integer.MIN_VALUE son los límites de int; pasarlo hace que se reenvuelva (un desbordamiento).
Una variable objeto que no apunta a ningún objeto contiene null; llamar un método sobre ella lanza un NullPointerException.
2.3
Conversión y cambio de tipo
Un cast 强制转换 cambia el tipo de un valor. (int) elimina la parte decimal; (double) evita la división entera cuando necesitas un resultado exacto.
public class Main {
public static void main(String[] args) {
double pi = 3.99;
System.out.println((int) pi); // 3
int total = 7, n = 2;
System.out.println((double) total / n); // 3.5
}
}
Errores comunes
División entera: 5 / 2 es 2, no 2.5. Castea primero: (double) 5 / 2.
Compara Strings (y otros objetos) con .equals(), no con ==.
== en dos objetos prueba si son el MISMO objeto, no si se ven iguales.
3Booleanos y selección
3.1
if / else
if ejecuta un bloque cuando una condición es verdadera; else if y else añaden más casos. La condición va en ( ), el bloque en { }.
public class Main {
public static void main(String[] args) {
int score = 72;
if (score >= 80) {
System.out.println("A");
} else if (score >= 60) {
System.out.println("B");
} else {
System.out.println("fail");
}
}
}
if elige la rama verdadera; else la rama falsa
3.2
Operadores lógicos y comparaciones
Compare con ==, !=, <, >, <=, >= — una comparación da como resultado un boolean. Combine con && (y), || (o), ! (no) — los operadores lógicos. Para Strings, use .equals(...), no==.
public class Main {
public static void main(String[] args) {
int age = 16;
boolean member = true;
System.out.println(age >= 18 && member); // false
String a = "hi";
System.out.println(a.equals("hi")); // true
}
}
3.3
switch
switch elige entre muchos valores fijos. Use break para omitir un caso; sin él, la ejecución puede continuar al siguiente caso. default es el valor predeterminado.
public class Main {
public static void main(String[] args) {
int day = 3;
switch (day) {
case 1: System.out.println("Mon"); break;
case 3: System.out.println("Wed"); break;
default: System.out.println("other");
}
}
}
Errores comunes
Una condición debe ser de tipo boolean; if (x = 5) no compila (utilice ==).
En un switch, break, return o throw pueden detener la propagación hacia abajo. Al llegar al siguiente caso sin uno de ellos, la ejecución continúa allí.
&& y || cortocircuitan. & y | operan bit a bit sobre enteros; con booleanos, evalúan ambos operandos.
4Bucles
4.1
bucles while
Un bucle while se repite mientras una condición sea verdadera. Si no se modifica algo en su interior, el bucle se ejecutará indefinidamente.
public class Main {
public static void main(String[] args) {
int n = 1;
while (n <= 3) {
System.out.println(n);
n++;
}
}
}
El bucle while verifica la condición antes de cada paso del cuerpo
4.2
bucles for
Un bucle for agrupa el inicio, la condición y el paso en una sola línea. Es ideal cuando se conoce la cantidad de iteraciones.
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.print(i + " ");
}
System.out.println(); // 0 1 2 3 4
}
}
4.3
Acumulación
El patrón del acumulador: iniciar una variable antes del bucle y luego actualizarla en cada vuelta.
public class Main {
public static void main(String[] args) {
int total = 0;
for (int i = 1; i <= 5; i++) {
total += i;
}
System.out.println(total); // 15
}
}
4.4
Bucle anidados
Un bucle dentro de otro es un bucle anidado. El bucle interno se ejecuta completamente en cada vuelta del bucle externo.
public class Main {
public static void main(String[] args) {
for (int r = 0; r < 3; r++) {
for (int c = 0; c < 3; c++) {
System.out.print("*");
}
System.out.println();
}
}
}
Errores comunes
for (int i = 0; i < n; i++) se ejecuta n veces (0 a n - 1); usar <= ejecuta una vez más.
No coloque un punto y coma inmediatamente después de for (...) o while (...), ya que esto crea un bucle vacío.
Declare el contador en el encabezado del for para que su alcance termine junto con el bucle.
5Cadenas (Strings)
5.1
Métodos de String
Un String es texto. Métodos útiles: .length(), .charAt(i), .substring(a, b), .indexOf(x), .toUpperCase(), .equals(...). Las cadenas son inmutables: su contenido no puede modificarse. Los métodos pueden devolver números, booleanos o cadenas; una String devuelta puede reutilizar un objeto existente.
public class Main {
public static void main(String[] args) {
String s = "Python";
System.out.println(s.length()); // 6
System.out.println(s.charAt(0)); // P
System.out.println(s.substring(0, 3)); // Pyt
System.out.println(s.toUpperCase()); // PYTHON
}
}
Los métodos que usarás a diario:
Método
Significado
Ejemplo → resultado
.length()
cuántos caracteres
"Hi".length() → 2
.charAt(i)
un carácter
"Hi".charAt(0) → H
.substring(a, b)
parte, se detiene antes de b
"Python".substring(0, 3) → Pyt
.substring(a)
desde a hasta el final
"Python".substring(3) → hon
.indexOf(x)
primera posición, -1 si está ausente
"banana".indexOf("na") → 2
.equals(s)
¿mismo texto?
"hi".equals("hi") → true
.compareTo(s)
orden: negativo / 0 / positivo
"apple".compareTo("banana") → negativo
compareTo compara unidades de código UTF-16 lexicográficamente, distinguiendo mayúsculas de minúsculas (por ejemplo, "Z" viene antes que "a") — el examen AP lo usa para preguntas de ordenamiento:
public class Main {
public static void main(String[] args) {
String a = "apple", b = "banana";
System.out.println(a.compareTo(b) < 0); // true (apple comes first)
System.out.println(a.compareTo("apple")); // 0 (equal)
}
}
Métodos clave de Strings: length, charAt, substring, equals
5.2
Construcción y recorrido de cadenas
Une las cadenas con + (concatenación). Recorre cada carácter con un bucle y .charAt(i).
public class Main {
public static void main(String[] args) {
String word = "banana";
int count = 0;
for (int i = 0; i < word.length(); i++) {
if (word.charAt(i) == 'a') count++;
}
System.out.println(count); // 3
}
}
Al construir una cadena larga dentro de un bucle, StringBuilder es mucho más rápido: se concatenan las piezas y luego se llama a .toString() una sola vez.
public class Main {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
sb.append(i).append(" ");
}
System.out.println(sb.toString().trim()); // 1 2 3 4 5
}
}
Errores comunes
Las cadenas son inmutables: s.toUpperCase() devuelve el resultado en mayúsculas sin modificar s, por lo que debes almacenar el resultado.
Lea un carácter con s.charAt(i); la longitud es s.length() (un método, con ()).
Construir una cadena con += en un bucle grande es lento; utilice un StringBuilder.
6Arreglos (Arrays)
6.1
Arreglos 1-D
Un array 数组 contiene un número fijo de valores de un mismo tipo. Los índices comienzan en 0, y se obtiene el tamaño con .length.
public class Main {
public static void main(String[] args) {
int[] scores = {88, 71, 95};
System.out.println(scores[0]); // 88
System.out.println(scores.length); // 3
scores[1] = 100;
System.out.println(scores[1]); // 100
}
}
Un valor primitivo guarda su valor; una variable de array guarda una referencia al objeto array
6.2
Algoritmos de array
Recorra el array con un bucle para encontrar un máximo, un total, un conteo o para buscar 查找. Un bucle for-each (for (int x : a)) lee cada valor por turno.
public class Main {
public static void main(String[] args) {
int[] a = {3, 9, 2, 7};
int max = a[0], total = 0;
for (int x : a) {
if (x > max) max = x;
total += x;
}
System.out.println(max + " " + total); // 9 21
}
}
6.3
Arrays 2-D
Un array 2-D 二维数组 es una cuadrícula 网格 de filas y columnas: grid[row][col].
public class Main {
public static void main(String[] args) {
int[][] grid = {{1, 2, 3}, {4, 5, 6}};
System.out.println(grid[1][2]); // 6
for (int[] row : grid) {
for (int v : row) System.out.print(v + " ");
}
System.out.println(); // 1 2 3 4 5 6
}
}
Errores comunes
El tamaño de un array es a.length (sin corchetes, sin ()), y es fijo cuando se crea.
Los índices válidos van de 0 a a.length - 1; a[a.length] lanza ArrayIndexOutOfBoundsException.
Un nuevo int[5] se rellena con ceros, no queda vacío.
7ArrayList
7.1
Fundamentos de ArrayList
Un ArrayList es una lista de tamaño variable — crece y se encoge a medida que agregas o eliminas elementos. Almacena objetos, por lo que debes usar un tipo envoltorio (wrapper) como Integer (no int). La parte <Integer> es un tipo genérico (generic type). Métodos clave: .add(x), .get(i), .set(i, x), .size(), .remove(i).
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(10);
nums.add(20);
nums.add(30);
System.out.println(nums.size()); // 3
System.out.println(nums.get(1)); // 20
nums.set(0, 99);
System.out.println(nums); // [99, 20, 30]
}
}
ArrayList: agregar, obtener, tamaño en una lista de tamaño variable
7.2
Algoritmos de ArrayList y el error de remove
.remove(i) desplaza cada elemento posterior un lugar hacia la izquierda. Si eliminas mientras cuentas ihacia arriba, omitirás el siguiente elemento. Solución: recorre el bucle hacia atrás, o no incrementes i después de una eliminación.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> nums = new ArrayList<Integer>();
for (int n : new int[]{4, 7, 4, 9, 4}) nums.add(n);
// Remove every 4 — loop backwards so removals don't skip items.
for (int i = nums.size() - 1; i >= 0; i--) {
if (nums.get(i) == 4) nums.remove(i);
}
System.out.println(nums); // [7, 9]
}
}
Errores comunes
ArrayList utiliza .size(), .get(i) y .add(...) — no los corchetes [] que usas en los arrays.
Eliminar elementos mientras se itera hacia adelante por índice omite el siguiente elemento (el error de remove). Recorre hacia atrás, o usa un iterator.
Almacena objetos, no primitivas: usa ArrayList<Integer>, y Java hace el autoboxing automático de valores int.
8Escritura de clases
8.1
Campos, constructor y métodos
Una clase es un plano para objetos. Sus campos almacenan datos, su constructor configura un nuevo objeto, y sus métodos son las acciones. this.name significa "el name de este objeto". Cree un objeto con new.
public class Main {
public static void main(String[] args) {
Dog d = new Dog("Rex", 3);
System.out.println(d.describe()); // Rex is 3 years old
d.haveBirthday();
System.out.println(d.describe()); // Rex is 4 years old
}
}
class Dog {
private String name;
private int age;
public Dog(String name, int age) { // constructor
this.name = name;
this.age = age;
}
public String describe() {
return name + " is " + age + " years old";
}
public void haveBirthday() {
age++;
}
}
Un miembro static pertenece a la propia clase, no a ningún objeto en particular. Llama a un método estático usando el nombre de la clase —como Math.max—, y un campo estático es compartido por todos los objetos:
public class Main {
public static void main(String[] args) {
System.out.println(Counter.made()); // 0
new Counter();
new Counter();
System.out.println(Counter.made()); // 2
}
}
class Counter {
private static int count = 0; // shared by ALL Counter objects
public Counter() { count++; }
public static int made() { // called on the class: Counter.made()
return count;
}
}
Los campos almacenan el estado; el constructor construye; los métodos actúan
8.2
Encapsulación
El encapsulamiento controla el acceso al estado del objeto. Marque los campos como private para bloquear el acceso directo desde clases no relacionadas; un accesor (getter) lee el estado y un mutador lo cambia. Un setter es un tipo de mutador. private no valida valores: los constructores y métodos mutadores necesitan sus propias comprobaciones o precondiciones declaradas. Este ejemplo asume un start no negativo y sumas que caben en int; su método deposit rechaza importes no positivos.
public class Main {
public static void main(String[] args) {
Account a = new Account(100);
a.deposit(50);
a.deposit(-999); // rejected by the guard
System.out.println(a.getBalance()); // 150
}
}
class Account {
private int balance; // hidden from outside
public Account(int start) {
balance = start;
}
public void deposit(int amount) {
if (amount > 0) balance += amount; // this guard checks the deposit amount
}
public int getBalance() { // accessor (getter)
return balance;
}
}
Errores comunes
Un constructor tiene el nombre de la clase y no tiene tipo de retorno (ni siquiera void).
Usa this.field para distinguir un campo de un parámetro con el mismo nombre.
Define los campos como private y accede a ellos mediante métodos getter/setter (encapsulamiento).
9Herencia y polimorfismo
9.1
Herencia
La herencia permite que una subclase reutilice una superclase. Escribe class Cat extends Animal y Cat hereda los campos y métodos aptos de Animal. Los miembros privados no se heredan; los constructores tampoco. Llama al constructor del padre con super(...).
public class Main {
public static void main(String[] args) {
Cat c = new Cat("Milo");
c.eat(); // Milo is eating (inherited from Animal)
c.speak(); // Meow (Cat's own method)
}
}
class Animal {
protected String name;
public Animal(String name) { this.name = name; }
public void eat() { System.out.println(name + " is eating"); }
}
class Cat extends Animal {
public Cat(String name) { super(name); } // call Animal's constructor
public void speak() { System.out.println("Meow"); }
}
Gato y Perro extienden Animal: heredan sus miembros y añaden los suyos propios
9.2
Polimorfismo & toString
Una subclase puede sobrescribir un método para reemplazar la versión del padre. La polimorfía significa que una variable de tipo Shape puede contener cualquier subtipo, y Java selecciona el toString correcto en tiempo de ejecución. System.out.println(obj) llama automáticamente a obj.toString().
public class Main {
public static void main(String[] args) {
Shape[] shapes = { new Circle(2), new Square(3) };
for (Shape s : shapes) {
System.out.println(s); // each calls its own toString
}
}
}
class Shape {
public String toString() { return "a shape"; }
}
class Circle extends Shape {
private int r;
public Circle(int r) { this.r = r; }
public String toString() { return "Circle r=" + r; } // override
}
class Square extends Shape {
private int side;
public Square(int side) { this.side = side; }
public String toString() { return "Square side=" + side; } // override
}
Errores comunes
Un método que sobrescribe debe coincidir exactamente con la firma; añade @Override para que el compilador detecte errores.
super(...) debe ser la primera línea de un constructor de subclase.
Un objeto de subclase ES UN objeto de superclase, pero no al revés.
10Recursión
10.1
Recursión
La recursión 递归 es un método que se llama a sí mismo. Toda recursión necesita un caso base 基准情形 (cuándo detenerse) y una llamada recursiva 递归调用 que la acerque a ese caso. Sin un caso base, nunca se detiene y falla con un desbordamiento de pila (stack overflow).
La pila de llamadas para factorial(3): cada espera, luego retorna en orden inverso
public class Main {
public static void main(String[] args) {
System.out.println(factorial(5)); // 120
}
public static int factorial(int n) {
if (n <= 1) return 1; // base case
return n * factorial(n - 1); // recursive call: n * (n-1)!
}
}
Rastrea el proceso: factorial(5) espera a factorial(4), que espera a factorial(3)… hasta que factorial(1) retorna 1. Luego las respuestas se multiplican hacia arriba: 1 → 2 → 6 → 24 → 120.
La recursión también funciona con Cadenas — separa un carácter por llamada:
public class Main {
public static void main(String[] args) {
System.out.println(reverse("PYTHON")); // NOHTYP
}
static String reverse(String s) {
if (s.length() <= 1) return s; // base case
return reverse(s.substring(1)) + s.charAt(0);
}
}
Merge sort 归并排序 es el ordenamiento recursivo en el examen AP: divide el array a la mitad, ordena cada mitad recursivamente, luego fusiona 合并 las dos mitades ordenadas. Ejecuta en O(n log n) — mucho más rápido que los ordenamientos O(n²) en arrays grandes.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7, 3};
mergeSort(a, 0, a.length - 1);
System.out.println(Arrays.toString(a)); // [1, 2, 3, 5, 7, 9]
}
static void mergeSort(int[] a, int lo, int hi) {
if (lo >= hi) return; // base case: one element
int mid = (lo + hi) / 2;
mergeSort(a, lo, mid); // sort the left half
mergeSort(a, mid + 1, hi); // sort the right half
merge(a, lo, mid, hi); // merge the two halves
}
static void merge(int[] a, int lo, int mid, int hi) {
int[] tmp = new int[hi - lo + 1];
int i = lo, j = mid + 1, k = 0;
while (i <= mid && j <= hi) {
if (a[i] <= a[j]) tmp[k++] = a[i++];
else tmp[k++] = a[j++];
}
while (i <= mid) tmp[k++] = a[i++];
while (j <= hi) tmp[k++] = a[j++];
for (k = 0; k < tmp.length; k++) a[lo + k] = tmp[k];
}
}
Errores comunes
La recursión necesita un caso base, o lanzará StackOverflowError.
Cada llamada recursiva debe acercarse MÁS al caso base.
Rastrea un ejemplo pequeño a mano para verificar que la recursión retorna el valor correcto.
En merge sort, el paso de fusión hace el trabajo real; la recursión solo divide el array.
11Búsqueda y ordenamiento
11.1
Búsqueda lineal y búsqueda binaria
La búsqueda lineal 线性查找 revisa cada elemento — funciona con cualquier arreglo. La búsqueda binaria 二分查找 es mucho más rápida, pero necesita un arreglo ordenado 已排序: examina el elemento central y descarta la mitad del rango en cada paso. Ambas devuelven el índice, o -1 si no se encuentra.
public class Main {
public static void main(String[] args) {
int[] a = {2, 5, 8, 12, 16, 23}; // sorted, so binary search works
System.out.println(linear(a, 12)); // 3
System.out.println(binary(a, 12)); // 3
System.out.println(binary(a, 9)); // -1 (not found)
}
static int linear(int[] a, int target) {
for (int i = 0; i < a.length; i++)
if (a[i] == target) return i;
return -1;
}
static int binary(int[] a, int target) {
int lo = 0, hi = a.length - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == target) return mid;
else if (a[mid] < target) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
}
La búsqueda binaria reduce a la mitad el rango en cada paso, por lo que busca en un arreglo ordenado en O(log n)
11.2
Ordenamiento por selección e inserción
El ordenamiento por selección 选择排序 encuentra repetidamente el valor restante más pequeño y lo intercambia hacia el principio. El ordenamiento por inserción 插入排序 toma cada valor y lo desliza hacia atrás para colocarlo entre los valores ya ordenados.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7};
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++)
if (a[j] < a[min]) min = j;
int t = a[min]; a[min] = a[i]; a[i] = t; // swap into place
}
System.out.println(Arrays.toString(a)); // [1, 2, 5, 7, 9]
}
}
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7};
for (int i = 1; i < a.length; i++) {
int key = a[i], j = i - 1;
while (j >= 0 && a[j] > key) { // shift bigger values right
a[j + 1] = a[j];
j--;
}
a[j + 1] = key; // drop key into the gap
}
System.out.println(Arrays.toString(a)); // [1, 2, 5, 7, 9]
}
}
Comparación de velocidades:
Algoritmo
Tiempo
búsqueda lineal
O(n)
búsqueda binaria
O(log n), solo arreglos ordenados
ordenamiento por selección / inserción
O(n²)
ordenamiento por fusión (tema 10)
O(n log n)
Errores comunes
La búsqueda binaria solo funciona en un arreglo ordenado.
La búsqueda lineal es O(n); la búsqueda binaria es O(log n) pero requiere primero el ordenamiento.
El ordenamiento por selección y por inserción son O(n²) — fáciles de aprender, lentos con grandes volúmenes de datos.
12Archivos y la AP FRQ
12.1
Archivos de texto con Scanner
Un Scanner lee texto línea por línea. Para un archivo real, se escribe new Scanner(new File("scores.txt")); aquí enmarcamos un String para que el ejemplo funcione en cualquier lugar. Use .split(" ") para dividir una línea en partes y Integer.parseInt(...) para analizar un número a partir de texto.
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Real file: Scanner in = new Scanner(new File("scores.txt"));
String data = "Alice 80\nBob 95\nCara 72";
Scanner in = new Scanner(data);
int total = 0, count = 0;
while (in.hasNextLine()) {
String line = in.nextLine();
String[] parts = line.split(" "); // break the line on the space
total += Integer.parseInt(parts[1]);
count++;
}
System.out.println("average = " + (total / count)); // average = 82
}
}
El Scanner lee líneas mientras hasNextLine sea true
12.2
Tipos de preguntas del FRQ de AP
El examen de AP CS A tiene cuatro preguntas de respuesta libre, cada una con una forma fija:
P1 — Métodos y control: escribir métodos según una especificación dada; bucles, if, String/Math.
P2 — Diseño de clases: escribir una clase completa (campos, constructor, métodos) a partir de una descripción.
P3 — Arreglo / ArrayList: procesar un arreglo 1-D o ArrayList (búsqueda, conteo, construir una nueva lista).
P4 — Arreglo 2-D: recorrer una cuadrícula por fila y columna.
La habilidad siempre es la misma: leer la especificación, escribir el método exactamente como se describe y devolver el tipo correcto.
public class Main {
public static void main(String[] args) {
// Q1 style: implement a method to a spec, then it is tested.
System.out.println(countEven(new int[]{4, 7, 10, 3, 6})); // 3
}
/** Returns how many values in arr are even. */
public static int countEven(int[] arr) {
int count = 0;
for (int x : arr)
if (x % 2 == 0) count++;
return count;
}
}
Errores comunes
nextInt() deja el salto de línea pendiente, por lo que un nextLine() posterior lee una línea vacía; léala primero para eliminarla.
Verifique hasNext() antes de leer, para evitar excederse al final del archivo.
En el FRQ, lea cuidadosamente el encabezado del método: coincida exactamente con el tipo de retorno y los parámetros.