Multiplos de un numero
import java.util.*;
public class Main
{
static int n=10;
static int arg[]=new int[n];
void AnalizaVariable(int var)
{
if(var%5==0)
System.out.println(var+" es multiplo de 5");
else
System.out.println(var+" no es multiplo de 5");
}
public static void main(String[] args)
{
int j=0;
Main variable = new Main();
if(arg.length==0)
{
System.out.println("Necesita Ingresar un Parámetro");
}
else
{
for(int i=0;i<arg.length;i++)
{
j=(int)(Math.random()*20+1);
variable.AnalizaVariable(j);
}
}
}
}
SALIDA
10 es multiplo de 5
5 es multiplo de 5
1 no es multiplo de 5
13 no es multiplo de 5
15 es multiplo de 5
16 no es multiplo de 5
11 no es multiplo de 5
10 es multiplo de 5
9 no es multiplo de 5
7 no es multiplo de 5Tipos primitivos en Java y tipos complejos en Java. Variables y su uso en Java
La intención principal de esta sección es dar una introducción a lo que se refiere al sistema de tipos de Java, el sistema de tipos en java y las variables en Java en particular poseen una gran extensión de temas por cubrir, por lo que en este único artículo daremos solo una mirada general. Hablaremos específicamente acerca de los tipos de datos o variables más comunes, sus características generales, su utilidad, los usos más comunes, entre otras cosas, sin embargo no pretendo profundizar en detalles, pues para ello están las secciones que componen a este contenido.
En la primera sección hablaremos con detalle acerca de variables y tipos en Java y en la segunda sección hablaremos también con detalle acerca de constantes y modificador final en Java, pero eso será en cada sección, por lo que a este artículo corresponde, como mencioné antes, solo veremos conceptos generales y una introducción al sistema de tipos de Java, así que comencemos.
Cuando hablamos del sistema de tipos en Java, nos estamos refiriendo a todos los tipos de datos (no solo los nativos o primitivos) que posee el lenguaje, es decir, el sistema de tipos está conformado por todos los tipos que se le pueden asignar a las diferentes variables dentro de una aplicación en Java y estos provienen de la definición misma del lenguaje, es decir, nosotros no debemos crear el tipo sino que Java ya lo trae creado para nosotros y lo podemos usar en cualquier momento. Estos tipos de datos provienen de la librería estándar de Java y todos podemos hacer uso de ellos.
De lo anterior entonces, podemos decir que los tipos de datos creados por el usuario (clases) no conforman el sistema de tipos de Java, sin embargo no dejan de ser un tipo de dato, simplemente, no son un tipo de dato estandar sino como lo dije antes, son un tipo de dato creado por el usuario y quiza conformen un sistema de tipos propio del usuario, mas no de Java como tal.
Como podrás imaginar Java posee una enorme cantidad de tipos de datos, sin embargo de una manera más general, algunos de estos son más sencillos simples de usar que otros. Veamos:
Tipos nativos o primitivos de Java
Los tipos nativos de Java, son los tipos de datos "fáciles de usar" es decir, como veremos un poco más adelante, no es necesario crear un objeto de manera explícita para hacer uso de ellos. Los tipos primitivos como su nombre lo da a entender, son los tipos de datos más básicos y simples del sistema de tipos de Java y por ello es bastante fácil usarlos. Veamos a continuación cuáles son estos tipos de datos primitivos y sus características.
¿Cuáles son los tipos primitivos de Java?
Java posee un total de ocho tipos primitivos, que cubren todo tipo de números (reales o decimales y enteros) cada uno con una extensión o magnitud máxima, también cubre los valores lógicos (falso y verdadero) e incluye caracteres. Nota: Debo advertir aquí que Java no incluye en sus tipos primitivos las cadenas de caracteres (Strings) pues en este lenguaje (de hecho no es el único) son representados por medio de la clase String.
Tipo primitivo char
Este tipo de dato permite representar caracteres aislados, es decir, por medio de un único char no podemos representar palabras completas sino más bien letras individuales. Por ejemplo entonces la palabra "carácter" estaría conformada por un total de ocho chars ‘c’, ‘a’, ‘r’, ‘a’, ‘c’, ‘t’, ‘e’ y ‘r’. Un char tiene un peso fijo (independientemente de la letra) de 16 bit.
Tipo boolean
El tipo de dato primitivo boolean nos permite representar valores lógicos o booleanos (falso y verdadero). Una variable boolean, solo puede tomar dos posibles valores false (falso) o true (verdadero), este tipo de variables son especialmente usadas para evaluar condiciones en las cuales es necesario conocer el valor de verdad de cierta operación lógica. Tiene un peso de 16 bit.
Tipo de dato byte
Este tipo de datos representa pequeños números enteros (8 bit), puede contener números entre -128 y 127.
El tipo short
Este es usado para representar números enteros más grandes que byte (aunque no demasiado) tiene un peso de 16 bit y varía entre -32768 y 32767
Tipo primitivo int
Este tipo de dato es uno de los más populares entre una gran variedad de programadores, pues generalmente cuando se piensa en un número entero inmediatamente se coloca la variable como tipo int, sin embargo generalmente int suele ser más grande de lo que llegamos a necesitar, desperdiciando así algunos bits en memoria. Un tipo int tiene un peso de 32 bit con signo, es decir va desde -2 a la 31 hasta 2 a la 32, aproximadamente desde -2.147’483.648 hasta 2.147’483.647.
El tipo long
El tipo primitivo long es usado para representar números enteros realmente grandes, del orden de -2 a la 63 hasta 2 a la 64. Vemos entonces que un long tiene un tamaño de 64 bit y varía aproximadamente desde -9.223’’372.036.854’775.808 hasta 9.223’’372.036.854’775.807.
Tipo primitivo float
El tipo float es quizás el segundo más usado, es útil cuando queremos representar números decimales, como por ejemplo resultados de divisiones, raíces o similares. Son también grandes (su tamaño es de 32 bit) y cubren un gran rango de posibles valores.
Tipo de dato double
Este tipo es el tipo de dato numérico más grande, con este podemos representar casi cualquier número que necesitemos, es demasiado improbable que necesitemos un número que supere la capacidad de éste (aunque existen unos pocos casos en los que sí), tienen un peso de 64 bit.
Muy bien ya hemos visto y conocido los tipos de datos primitivos de Java, sin embargo como mencioné al principio de esta sección, los tipos primitivos son solo una parte del sistema de tipos de Java, así que veamos a continuación los tipos de datos que nos hacen falta para completar nuestro sistema de tipos:
Tipos complejos o compuestos en java
Dado que Java es un lenguaje de programación orientado a objetos no nos debe sorprender el hecho de que una gran cantidad de los tipos que conforman su sistema de tipos de datos sean tipos complejos (objetos que provienen de clases).
La librería estándar de Java está conformada por cientos (quizás miles) de clases que representan en última instancia un tipo de dato particular. Cabe resaltar que nosotros como programadores podemos crear nuestros propios tipos de datos a partir de los que conforman el sistema propio de Java, sin embargo al ser tipos nuestros no conforman parte del estándar de java y por ende no son parte oficial del sistema de tipos del lenguaje.
Una de las principales clases que conforman estos tipos complejos es la clase String, los String no son un tipo primitivo (son objetos), sin embargo está conformado por una serie (una cadena) de chars (los cuales sí son primitivos), al ser una clase como tal, posee una serie de atributos y métodos que podemos usar para manipular nuestra cadena de caracteres. No pretendo mencionar todas las clases o tipos complejos que conforman el sistema de tipos de Java, sin embargo mencionaré de manera general los que son comúnmente usados, veamos:
Tipos de la biblioteca estándar de java
La clase String
Ya he hablado un poco de esta clase. Con ésta podemos crear cadenas de caracteres con gran facilidad (Strings), de hecho se diferencia por esto de los demás tipos complejos, pues no es necesario el uso del comando new para crear objetos de tipo String, basta con poner la cadena entre comillas dobles "palabra" e igualarla con una variable de tipo String y con eso bastará. En la sección de variables y tipos en Java explicaré con mayor detalle cómo se crean y usan los String en java. La clase String posee una serie de métodos que nos permiten realizar tareas como determinar el tamaño de la cadena (el número de caracteres), determinar la posición de un carácter en especifico, reemplazar ciertas secciones de la cadena por otras, y muchas más. Puedes conocer más de esta clase en la documentación oficial de Strings en Java
Unir Vectores
import java.util.*
public class Main
{
static int MAX=20;
static int MAX2=MAX*2;
static int A[]=new int[MAX];
static int B[]=new int[MAX];
static int C[]=new int[MAX2];
static void llenaArreglo(int arreglo[])
{
for(int i=0;i<arreglo.length;i++)
{
int ban;
do{
arreglo[i]=(int)(Math.random()*100+1);
ban=noDuplicar(arreglo,arreglo[i],i);
}while(ban==1);
}
}
static int noDuplicar(int arreglo[], int numero, int longitud)
{
int ban=0;
for(int i=0;i<longitud;i++)
{
if(numero==arreglo[i])
{ban=1;break;}
else
ban=0;
}
return ban;
}
static void ordenar(int arreglo[])
{
int temp=0;
for(int i=1;i<arreglo.length;i++)
{
for(int j=0;j<arreglo.length-i;j++)
{
if(arreglo[j]>arreglo[j+1])
{
temp=arreglo[j];
arreglo[j]=arreglo[j+1];
arreglo[j+1]=temp;
}
}
}
}
static void juntarArreglos()
{
int j=0,ban=0,cant=0,k=0,m=0,v=1;
for(int i=0;i<C.length;i++)
{
C[i]=A[j];
ban=noDuplicar(C, C[i], i);
C[i+1]=B[j];
ban=noDuplicar(C, C[i+1], (i+1));
i++;
j++;
}
ordenar(C);
cant=(C.length);
for(int i=0;i<cant-1;i++)
{
if(C[i]==C[i+1])
{ k=i; m++;}
for(int l=k;l<cant-1;l++)
{
C[l]=C[l+1];
}
}
while(C[cant-v]==C[cant-v-1])
{
C[MAX2-v]=0;
v++;
}
}
static void mostrar(int arreglo[],String n)
{
for(int i=0;i<arreglo.length;i++)
{
System.out.print(n+"["+i+"] : "+arreglo[i]);
System.out.println("");
}
System.out.print("\n");
}
public static void main(String[] args)
{
llenaArreglo(A);
llenaArreglo(B);
ordenar(A);
ordenar(B);
mostrar(A,"A");
mostrar(B,"B");
juntarArreglos();
mostrar(C,"C");
}
}
VELOCIDAD FINAL
import java.util.*;
public class Main
{
double vo=0,aceleracion=8;
double VelocidadMedia()
{
//velocidad_final=velocidad_inicial+(aceleracion*tiempo)
double vf=0,tiempo=5;
vf=vo+(aceleracion*tiempo);
double speedMedia=(vo+vf)/2;
return speedMedia;
}
double VelocidadInstant()
{
double tiempo=5;
double speedInst=(vo+aceleracion*tiempo);
return speedInst;
}
public static void main(String[] args)
{
DSCSpeedy coche = new DSCSpeedy();
double vMedia=coche.VelocidadMedia();
System.out.println(vMedia+" m/s");
double vInstantanea=coche.VelocidadInstant();
System.out.println(vInstantanea+" m/s");
}
}
MAXIMO COMO UN DIVISOR
//Calcula el Máximo Común Divisor (MCD) y el Mínimo Común Multiplo(MCM)
public class SyGMcd_Mcm
{
static int MAX=2;
static int mcd(int a, int b)
{
int x=0,nuevob=0;
x = a;
if (a < b)
{
a = b;
b = x;
System.out.println(a+" \t"+b);
return mcd(a,b);
}
else if (b != 0)
{
nuevob = a % b;
a = b;
b = nuevob;
System.out.println(a+" \t"+b);
return mcd(a,b);
}
return a;
}
static int mcm(int a, int b)
{
int m=0;
m=mcd(a,b);
return(m*(a/m)*(b/m));
}
public static void main(String[] args)
{
int d=0,a=0,b=0,c=0,e=0;
if(args.length3 )
System.out.println("\nIngrese 3 números como parámetros...\n");
else
{
a=Integer.parseInt(args[0]);
b=Integer.parseInt(args[1]);
c=Integer.parseInt(args[2]);
System.out.println("\n\n");
/*----Máximo Común Divisor------*/
d=mcd(a,b);
System.out.println("---------");
e=mcd(d,c);
System.out.println("MCD ("+a+","+b+","+c+") = "+e+"\n\n");
/*----Mínimo Común Múltiplo------*/
d=mcm(a,b);
System.out.println("---------");
e=mcm(d,c);
System.out.println("MCM ("+a+","+b+","+c+") = "+e+"\n\n");
}
}
}
No hay comentarios:
Publicar un comentario