Float, f e F, tem diferença?

Programação Java
#1

Saudações,

Alguém saberia me dizer qual a diferença entre o “f” e o “F” no final de um valor quando estou indicando o seu tipo? tem algo relacionado com a precisão?

por exemplo:

[code]float maiusculo = 3.14F;

float minusculo = 3.14f;[/code]

#2

Não, são formas de declaração que é permitido. Só para constar, vale o mesmo para long, hexadecimal, octal e double.

#3

[quote]
float maiusculo = 3.14F;

float minusculo = 3.14f;[/quote]

… os valores são idênticos… tanto faz usar “f” ou “F”… é claro que se você usar um padrão no seu código fica mais fácil de entender posteriormente…

#4

De modo geral, use “f” ou “F” para explicitar que uma constante é float (não recomendo; prefiro usar sempre “double”, exceto em casos muito restritos, como usar em Java2D), e “L” para explicitar que uma constante é long (não use “l”, embora seja permitido, porque se confunde com o dígito “1”).

Não é fácil achar um erro quando seus olhos não o enxergam:

long x = 10l; // 101 ou 10L?
int y = 017; // isto é um valor em octal, e seu valor em decimal é 15; 
// evite pôr zeros à esquerda dos números inteiros, 
// sempre que possível, para evitar confusão com números octais.
#5

obrigado pessoal, estou muitissimo grato.

#6

bom é como o pessoal falou nao faz diferença… mais cuidado para nao se confudir quando declarar variaveis…

...
int num;
int Num;

sao diferentes!! no java tem alguns recursos que A é == a e outros q a != A.

#7

Que situações a == A ?

#8

Espremendo um pouco o cérebro (preciso ler a Java Language Specification de cabo a rabo) acho que “a” e “A” são equivalentes apenas no seguinte caso: definir constantes hexadecimais ou Unicode (ou seja, só vale para ‘a’ até ‘f’).

Só nesse caso; em todos os outros lugares no Java, ‘a’ não é a mesma coisa que ‘A’.

int x = 0xcafe;
int y = 0xCAFE;
char c1 = '\ucafe';
char c2 = '\uCAFE';
#9

“Forçando a mente” e a criatividade…

[code]String a = “a”;

System.out.println(" ‘a’ é igual a ‘A’? " + a.compareToIgnoreCase(“A”));[/code]

=P

#10

Mas neste caso cassioso [code]“Forçando a mente” e a criatividade…

view plaincopy to clipboardprint?
String a = “a”;

System.out.println(" ‘a’ é igual a ‘A’? " + a.compareToIgnoreCase(“A”));
String a = “a”;

System.out.println(" ‘a’ é igual a ‘A’? " + a.compareToIgnoreCase(“A”));

=P [/code]

Você “trapasseou” porque comparar com ignoreCase, faz a seguinte operação
a = a.toUpperCase(a);

e depois verifica se os dois são iguais.
Portanto, ele compara os dois como maisculo.
a = A somente onde thingol citou.Que por sinal eu particulamente nunca vi ninguem utilizar isso.Mas…

#11

hehehe eu sei. :wink:

o compareToIgnoreCase faz um upperCase dentro dele? humm…

#12

O “compareToIgnoreCase” se comporta mais ou menos como se fosse isso (fizesse um toUpperCase), mas na verdade, lendo o código mais atentamente, ele percorre as duas strings, e verifica, caracter por caracter, o toUpperCase e o toLowerCase de cada um. É mais estranho que parece, mas isso é feito para levar em conta alguns casos estranhos (a letra i em turco, por exemplo).

    /**
     * A Comparator that orders <code>String</code> objects as by
     * <code>compareToIgnoreCase</code>. This comparator is serializable.
     * <p>
     * Note that this Comparator does <em>not</em> take locale into account,
     * and will result in an unsatisfactory ordering for certain locales.
     * The java.text package provides <em>Collators</em> to allow
     * locale-sensitive ordering.
     *
     * @see     java.text.Collator#compare(String, String)
     * @since   1.2
     */
    public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    private static class CaseInsensitiveComparator
                         implements Comparator<String>, java.io.Serializable {
	// use serialVersionUID from JDK 1.2.2 for interoperability
	private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
	    int n1 = s1.length();
	    int n2 = s2.length();
	    int min = Math.min(n1, n2);
	    for (int i = 0; i < min; i++) {
		char c1 = s1.charAt(i);
		char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
			    // No overflow because of numeric promotion
                            return c1 - c2;
			}
                    }
                }
            }
            return n1 - n2;
        }
    }
#13

Disso eu não sabia…

#14