Mensajes

[Request]

Aplicando el patrón DAO, representamos las tablas como clases:

Código (java) [Seleccionar] Expandir

public class Ticket {
private int id;
private Request request;
private double total;

public Ticket() {

}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Request getRequest() {
return request;
}
public void setRequest(Request request) {
this.request = request;
}
public double getTotal() {
return total;
}
public void setTotal(double total) {
this.total = total;
}
}

Código (java) [Seleccionar] Expandir

public class Request {
private int id;
private int state;

public Request() {

}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}

Creamos un método en el DAO de Request (pedido) que busque un pedido por ID:

Código (java) [Seleccionar] Expandir

public Request find(String id) {
String sql = "SELECT * FROM pedidos WHERE id_pedido = ?";

PreparedStatement preparedStatement=  null;
Connection connection = null;
ResultSet result = null;
Request request = null;
try {
connection = DBHelper.getConnection();
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1,id);
result = preparedStatement.executeQuery();

if(result.next()) {
request = new Request();
while(result.next()) {
request.setId(result.getString("request_id"));
request.setState(result.getInt("state"));
}
}
} catch (SQLException | NullPointerException e) {
logger.error("Ha ocurrido un error: "+e.getLocalizedMessage());
} finally {
if(connection != null)
connection.close();
if(preparedStatement != null)
preparedStatement.close();
if(result != null)
result.close();
}
return request;
}

Creamos un método que inserte un Ticket con un Request especificado:

Código (java) [Seleccionar] Expandir

public boolean insertTicket(Ticket ticket) {
String SQL = "INSERT INTO tickets(ticket_id, pedido_id, total)
VALUES(?,?,?)";
PreparedStatement preparedStatement=  null;
Connection connection = null;
boolean operationState = false;
try {
connection = DBHelper.getConnection();
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1,ticket.getId());
preparedStatement.setInt(2,ticket.getRequest().getId());
preparedStatement.setDouble(3,total);
operationState = preparedStatement.executeUpdate();

} catch (SQLException | NullPointerException e) {
logger.error("Ha ocurrido un error: "+e.getLocalizedMessage());
} finally {
if(connection != null)
connection.close();
if(preparedStatement != null)
preparedStatement.close();
}
return operationState;
}

Así o mantenemos simple y ordenado. Primero buscamos el pedido por ID. Si éste existe, creamos un nuevo objeto Ticket le asignamos un ID, un total y le asociamos un pedido (Request). Luego lo insertamos en la BD:

Código (java) [Seleccionar] Expandir

Request request = find(REQUEST_ID);
if(request != null) {
Ticket ticket = new Ticket();
ticket.setId(1);
ticket.setRequest(request);
ticket.setTotal(2000);
insertTicket(ticket);// o utilizar el boolean devuelto para algo...
}
else {
// mostrarle al usuario que el pedido no existe
}

Te recomiendo que uses el framework ORM Hibernate. Lee al respecto.

Para ser tu primer diseño está bien (visualmente, como está estructurado el html no sé). Tienes que aprender a combinar colores, a utilizar fuentes, eventos hover, focus, etc. Te recomiendo que vayas leyendo como funcionan las propiedades, position, display, margin, padding, width, height, etc. Eso para el posicionamiento, que a mí es lo que más se me complicó. Lo demás ya se aprende en el camino de acuerdo a lo que se te ocurra hacer, como por ejemplo, un sombreado (box-shadow) etc.

Saludos y sigue estudiando (Y).

No es complejo para nada, tan solo usas clases de la API de Java, totalmente estándar.

Lo que si tienes que tener en cuenta es que por más que intentes una vez que has definido el tamaño del array no podrás eliminar índices ni modificar dinámicamente el array. Como mucho podrás asignarle NULL a los índices pares.

Te recomiendo que sigas intentando hasta que consigas hacerlo a tu manera. Éste es el objetivo de los cursos de algoritmos, agilizar la lógica mental. Cuando lo logres, puedes colocar el código por si le sirve a otra persona.

Saludos.

Según tengo entendido, Java no utiliza mucho procesador, pero sí algo más de RAM. Por ejemplo, en un algoritmo de árboles binarios, C consume una media de ~150MB y Java puede llegar a consumir ~500MB, Python consume una media de 1.1GB y C++ algo de ~350MB.

Aquí pueden ver un benchmark de Java vs C/GCC.

[Versión con arrays:]

Cuando se programa se trata de mantener las cosas simples y, haciendo ésto con arrays lo estás complicando. De todos modos, te pondré dos versiones: una con arrays y otra con list.

Versión con arrays:

Código (=java) [Seleccionar] Expandir

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class ArrayDemo {

private Character[] letters  = new Character[30];
private Scanner reader = new Scanner(System.in);

/*
* Realiza un do while para ingresar datos
* hasta que se ingrese el centinela (0) lo cual
* indica que ya no se ingresaran más números
*/
void fillArray() throws IOException {

byte i = 0;
char letter;

do {
System.out.println("Introduce una letra o 0 para finalizar:");
letter = reader.next().charAt(0);
if( letter != '0') {
letters [i] = letter;
i++;
}
} while (letter != '0');
}

// imprime el array
void printArray() {

System.out.println("\n**** ARRAY ******\n");
for(Character letter : letters)
{
if(letter != null) {
System.out.println(letter);
}
}
}

/*
* Convierte el arreglo "letters" a lista, en concreto LinkedList para
* poder usar el método remove() sin necesidad de un iterator.
* Luego crea una lista "oddItems" que guardara los valores impares.
* Posteriormente, elimina todos los elementos NULL que tiene la lista convertida
* desde "letters" ya que los elementos vacíos de un array contienen NULL por defecto.
*
* Recorre la lista y evalúa si el index actual es par (quiere decir que el índice
* normal, es un impar porque en listas y arrays se empieza a contar por 0), guarda
* el elemento en la nueva lista "oddItems".
* seguidamente blankeo todo el array asignándole null a cada posición para que al
* guardar el nuevo array en "letters", éste esté limpio.
*
* Finalmente guardo el array "oddItems" en "letters".
*/
void deleteEvensIndex() {

List<Character> tempLetters = new LinkedList<Character> (Arrays.asList(letters));
List<Character> oddItems = new ArrayList<>();
tempLetters.removeAll(Collections.singleton(null));

for(int i=0; i<tempLetters.size(); i++)
{
if ( i % 2 == 0)
oddItems.add(tempLetters.get(i));
letters[i] = null;
}
letters = oddItems.toArray(letters);
}

}

Código (=java) [Seleccionar] Expandir

import java.io.IOException;

public class ArrayDemoTest {

public static void main(String[] args) {

ArrayDemo obj = new ArrayDemo();
try {
obj.fillArray();
obj.printArray();
obj.deleteEvensIndex();
obj.printArray();
} catch (IOException e) {
e.printStackTrace();
}

}

}

Versión con List:

Código (=java) [Seleccionar] Expandir

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class ListDemo {

private List<Character> letters;
private Scanner reader;

public ListDemo()
{
letters = new ArrayList<>();
reader = new Scanner(System.in);
}

/*
* Realiza un do while para ingresar datos
* hasta que se ingrese el centinela (0) lo cual
* indica que ya no se ingresaran más números
*/
public void fillList()
{
char letter;

do {
System.out.println("Introduce una letra o 0 para finalizar:");
letter = reader.next().charAt(0);
if( letter != '0') {
letters.add(letter);
}
} while (letter != '0');
}

/*
* Convierte el arreglo "letters" a lista, en concreto LinkedList para
* poder usar el método remove() sin necesidad de un iterator.
* Luego crea una lista "oddItems" que guardara los valores impares.
* Posteriormente, elimina todos los elementos NULL que tiene la lista convertida
* desde "letters" ya que los elementos vacíos de un array contienen NULL por defecto.
*
* Recorre la lista y evalúa si el index actual es par (quiere decir que el índice
* normal, es un impar porque en listas y arrays se empieza a contar por 0), guarda
* el elemento en la nueva lista "oddItems".
*
* Finalmente guardo el array "oddItems" en "letters".
*/
public void deleteEvensIndex()
{
List<Character> oddItems = new ArrayList<>();
for(int i=0; i<letters.size(); i++)
{
if(i % 2 == 0)
oddItems.add(letters.get(i));
}
letters = oddItems;
}

// imprime la lista
public void printList()
{
System.out.println("\n ******** DATA OF LIST ******** \n");
for(char c : letters)
{
System.out.println(c);
}
}

}

Código (=java) [Seleccionar] Expandir

public class ListDemoTest {

public static void main(String[] args) {

ListDemo ld = new ListDemo();
ld.fillList();
ld.printList();
ld.deleteEvensIndex();
ld.printList();

}

}

Salida:

Código [Seleccionar] Expandir

Introduce una letra o 0 para finalizar:
c
Introduce una letra o 0 para finalizar:
a
Introduce una letra o 0 para finalizar:
m
Introduce una letra o 0 para finalizar:
i
Introduce una letra o 0 para finalizar:
n
Introduce una letra o 0 para finalizar:
a
Introduce una letra o 0 para finalizar:
n
Introduce una letra o 0 para finalizar:
t
Introduce una letra o 0 para finalizar:
e
Introduce una letra o 0 para finalizar:
0

******** DATA OF LIST ********

c
a
m
i
n
a
n
t
e

******** DATA OF LIST ********

c
m
n
n
e

Si quieres que salga "aiat":

Código (=java) [Seleccionar] Expandir


if(i % 2 == 0) // remplaza por
if(i % 2 != 0)

Hmm, quizás ejecutándolo dentro de un Thread para que no interfiera con el thread principal puede mejorar la velocidad de procesamiento.

Alternativamente, te recomiendo colocar ésta duda que me parece muy interesante, en StackOverFlow, que estoy seguro te darán muy buenas respuestas los expertos. Para ésto, te recomiendo que re-escribas tu código en ingés.

Mi estimado @engel lex, sí es muy cierto que Java antes era un dinosaurio (me refiero a lo pesado xD). Pero en los últimos años, tanto el lenguaje como la JVM han sido optimizados mucho (como por ejemplo la implementación de la tecnología JIT en la JVM), dando como resultado un lenguaje y una JVM muchos más rápidos. Es más, en los últimos benchmarks que he podido observar, Java ejecuta la mayoría de algoritmos a la misma velocidad e incluso en algunos más que C++. Y con el esperado Jigsaw en Java 9, Java será una delicia xD

Lo asumo al leer ésta línea donde obtienes la sesión de Hibernate:

Código (=java) [Seleccionar] Expandir

RolPersonal rolPersonal = (RolPersonal) sessionFactory.getCurrentSession().createQuery(SQL_rolPersonal).uniqueResult();

Si usaras JPA harías:

Código (=java) [Seleccionar] Expandir

em.getTransaction().begin();
Query query = em.createQuery(sql);
...

[los impares]

No te entiendo.

es decir,si paso la  cadena
"caminante" la cadena quedara asi: "aiat"

¿Quieres decir que eliminas los impares y dejas solo los pares?

a -> 2
i -> 4
a -> 6
t -> 8

¿Esa cadena "caminante" la pasas en un array? ¿de qué forma?

"letras" que contiene mi array

¿Así?

Código (=java) [Seleccionar] Expandir


String[] array = {"c","a","m","i","n","a","n","t","e"};

Trata de explicar tu enunciado por partes para que se entienda qué es lo que pretendes hacer.

[no es posible remover posiciones]

Un array es una tipo de dato con un tamaño fijo, es decir, es estático. Una vez que le das un tamaño al array, ya no puede cambiar, por lo que no es posible remover posiciones como en otros lenguajes. Con objetos tipo List (y por ende las clases que lo implementan) si es posible.

Lo que puedes hacer es crear otro array y guardar allí los datos que estén en los índices impares:

Código (java) [Seleccionar] Expandir

int oddCount = (int) array.length / 2; // cuenta los indices impares

int[] otherArray = new int[oddCount];
for(byte i=0; i<oddCount; i++)
{
if(i % 2 != 0) // solo indices impares
otherArray = array[i];
}

Otra opción es convertirlo a lista y luego convertirlo nuevamente a array (tienes que trabajar con los Wrappers):

Código (java) [Seleccionar] Expandir


Integer[] array = {2,7,4,9,8};
Arrays.asList(array);

for(byte i=0; i<array.size(); i++)
{
if(i % 2 == 0)
array.remove(i);
}
Integer[] otherArray = array.toArray(new Integer[array.size()]);

[representa]

Claro. Recuerda que con los ORM trabajas siempre en base a objetos. Aunque UsuarioRolPersonal es una clase Java, representa a la tabla usuariorolpersonal. Por lo que los atributos de ésta clase, hacen referencia a las columnas de dicha tabla.

Supongo que Hibernate hará una consulta como:

Código (sql) [Seleccionar] Expandir

SELECT * FROM usuariorolpersonal u
WHERE u.id_usuario IN
(SELECT u.id_usuario FROM usuario u)

En tu archivo persistence.xml, puedes añadir la propiedad "show_sql" para ver el código SQL que fabrica Hibernate:

Código (xml) [Seleccionar] Expandir


<property name="show_sql" value="true"/>

Te recomiendo usar Hibernate como implementación de JPA y no Hibernate nativo. Usar siempre los estándars tienen sus ventajas. Además, siempre es posible obtener la sesión original de Hibernate para poder extender un poco JPA. Pero como recomendación, usar JPA con Hibernate o EclipseLink.