&& tem a mesma funçao de & e || tem a mesma funçao de | ?

|| é o operador ou lógico
&& é o operador e lógico
|| é o operador ou aritmético
& é o operador e aritmético

Os operadores logísticos só funcionam com operandos boolean
Já os operadores aritméticos funcionam com operandos byte, short, int e long e, como o nome sugere, servem para realizar operações aritméticas.

Outra diferença é ao utilizar em esses operadores em um if ou em um operador ternário com operandos boolean:

• Ao usar o operador &&, se o primeiro operando for false, o segundo operando nem é avaliado. Entretanto ao utilizar o operador &, ambos os operadores sempre são avaliados.
• Ao usar o operador ||, se o primeiro operando for true, o segundo operando nem é avaliado. Entretanto ao utilizar o operador |, ambos os operadores sempre são avaliados.

É aí que quero chegar. Eu fiz vários teste dentro de um IF para ver as diferenças entre & e &&.

Olha esse codigo simples que fiz de exemplo:

public static void main(String args[]) {

int x, y, z;

x = 10; y = 25; z = x+y;

if(x == 15 & y == 25){
    System.out.println("Sum of x+y = " + z);
    }
	 System.out.println("CODE ENDED");
}

Quando eu uso & e minha primeira conidção é falsa o IF devia avaliar a segunda condição e ver se é verdadeira. No caso desse trecho a segunda condição é verdadeira e, sendo assim, a maquina deveria imprimir: "Sum of x+y = " + z. Mas isso não acontece. A maquina pula direto para CODE ENDED.

Estou fazendo algo de errado? O que ficou dubentendido por mim?

& é aritimético, && operador lógico, logo, o correto é

if (x == 15 && y == 25){ // Se x for igual a 15 e y igual a 25.
sout("A soma de x + y é = " + z); //Acontece a resposta.
} else { //Senão:
sout("Fim do código"); //Fim do código.
}

Mas ele faz isso, ele só não entra no if pois a expressão num todo retorna false.
É uma operação e, só vai entrar no if quando ambos os operandos forem verdade.

Então o código tá correto?

Sim, a única diferença é que esta condição:

if (x == 15 && y == 25)

É mais rápida do que esta:

if (x == 15 & y == 25)

Se a única diferença é essa, existe algum motivo para esse operador não ser descontinuado? Afinal, se o && é até o padrão ensinado nas faculdades e ainda é superior em performance…

Essa é a única diferença na operação lógica postada acima.

Os operadores & e | servem para realizar a operações aritméticas E e OU e também operações lógicas E e OU.
Já os operadores && e || servem somente para realizar a operações lógicas E e OU.

Operações lógicas possuem operandos boolean.
Operações aritméticas possuem operadores byte, short, int ou long.

Pesquise por Álgebra de Boole.
Execute o exemplo abaixo para entender:

public class Exemplo {

    public static void main(String[] args) throws Exception {
        Exemplo programa = new Exemplo();
        programa.executar();
    }

    private int x = 10;
    private int y = 25;

    public void executar() {
        operacao_E_logica();
        operacao_E_aritmetica();
        outra_operacao_E_aritmetica();
    }

    private void operacao_E_logica() {
        System.out.println("executando E logico {");
        if (condicao1() && condicao2()) {
            System.out.println("  entrou no if");
        } else {
            System.out.println("  nao entrou no if");
        }
        System.out.println("}");
    }

    private void operacao_E_aritmetica() {
        System.out.println("executando E aritmetico {");
        if (condicao1() & condicao2()) {
            System.out.println("  entrou no if");
        } else {
            System.out.println("  nao entrou no if");
        }
        System.out.println("}");
    }

    private void outra_operacao_E_aritmetica() {
        System.out.println("executando outro E aritmetico {");
        int z = x & y;
        System.out.println("  x <- " + x + "    x = " + bits(x));
        System.out.println("  y <- " + y + "    y = " + bits(y));
        System.out.println("  z <-  " + z + "    z = " + bits(z));
        System.out.println("}");
    }

    private String bits(int n) {
        return String.format("%8s", Integer.toBinaryString(n)).replace(' ', '0');
    }

    private boolean condicao1() {
        int valor = 15;
        boolean resultado = x == valor;
        System.out.println("  condicao 1:    x <- " + x + "    x == " + valor + " -> " + resultado);
        return resultado;
    }

    private boolean condicao2() {
        int valor = 25;
        boolean resultado = y == valor;
        System.out.println("  condicao 2:    y <- " + y + "    y == " + valor + " -> " + resultado);
        return resultado;
    }
}

Mas isso desmente o

dito anteriormente

Me desculpa se não estou sendo compreensivo. É que fiz vários testes pesquisas em diferentes foruns e plataformas mas ainda não achei a resposta para essa minha dúvida.

Se a for diferente de b, a comparação de c e d nem vai ser executada

if(a == b && c == d) {}

Se a for diferente de b, a comparação de c e d vai ser executada e mesmo que de true, não vai entrar no if, pois as duas condições teriam que ser verdade

if(a == b & c == d) {}

Eu acho que o seu conceito de avaliação das condições está equivocado.
Quando você disse:

Quando eu uso & e minha primeira conidção é falsa o IF devia avaliar a segunda condição e ver se é verdadeira. No caso desse trecho a segunda condição é verdadeira e, sendo assim, a maquina deveria imprimir: "Sum of x+y = " + z. Mas isso não acontece. A maquina pula direto para CODE ENDED.

O operador E (tanto o && quanto o &) só vão retornar VERDADEIRO se ambas as afirmações são verdadeiras.
Utilizando seu próprio código como exemplo:

public class Exemplo{
    public static void main (String[] args){
        int x, y, z;
        x = 10; y = 25; z = x + y;
            if(x == 15 & y == 25){
                System.out.println("Sum of x+y = " + z);
            }
            System.out.println("CODE ENDED");
            }
        }

Nesse programa você está verificando SE a variável x é igual a 15 E a variável y é igual a 25, correto?
Foi atribuído o valor de x como sendo 10, logo é diferente de 15, então x == 15 vai retornar FALSO.
Se você utilizar &&, a segunda parte ( y == 25) não será analisada pelo programa, e vai para

System.out.println(“CODE ENDED”);

Já se você utilizar &, a segunda parte será analisada pelo programa e também vai para

System.out.println(“CODE ENDED”);

Isso porque só vai entrar no IF se x == 15 E y == 25.
Independente de qual operador você utilizar, PARA ESSE PROGRAMA não mudará o resultado.

Acredito que valha a pena você dar uma pesquisada sobre tabela verdade, pode ajudar.

Espero ter ajudado

Não precisa se desculpar, você está aprendendo.

Você já estudou álgebra de Boole?

Sabe como funcionam as operações lógicas OU e E?

Veja as tabelas verdade abaixo:

Operação OU

LÓGICA ( A || B )            ARITMÉTICA (A | B)
+-------+-------+-------+    +-------+-------+-------+
|   A   |   B   | Result|    |   A   |   B   | Result|
+-------+-------+-------+    +-------+-------+-------+
| false | false | false |    |   0   |   0   |   0   |
+-------+-------+-------+    +-------+-------+-------+
| false | true  | true  |    |   0   |   1   |   1   |
+-------+-------+-------+    +-------+-------+-------+
| true  | false | true  |    |   1   |   0   |   1   |
+-------+-------+-------+    +-------+-------+-------+
| true  | true  | true  |    |   1   |   1   |   1   |
+-------+-------+-------+    +-------+-------+-------+

Operação E

LÓGICA ( A && B )            ARITMÉTICA (A & B)
+-------+-------+-------+    +-------+-------+-------+
|   A   |   B   | Result|    |   A   |   B   | Result|
+-------+-------+-------+    +-------+-------+-------+
| false | false | false |    |   0   |   0   |   0   |
+-------+-------+-------+    +-------+-------+-------+
| false | true  | false |    |   0   |   1   |   0   |
+-------+-------+-------+    +-------+-------+-------+
| true  | false | false |    |   1   |   0   |   0   |
+-------+-------+-------+    +-------+-------+-------+
| true  | true  | true  |    |   1   |   1   |   1   |
+-------+-------+-------+    +-------+-------+-------+

No seu exemplo você inicializa duas variáveis:

x = 10
y = 25

E você tem duas condições:

x == 15
y == 25

Aí você escreveu um if com a seguinte expressão:

if (x == 15 & y == 25) {
    // condição verdadeira
} else {
    // condição falsa
}

Vamos dizer que:

x == 15 é a condição A
y == 25 é a condição B

Então podemos deduzir que:

A = false
B = true

Se você olhar as tabelas verdade acima, qual é o resultado da seguinte expressão?

A && B

Será false, por isso ele não entra no if

Se você prestar atenção nas tabelas verdade, a operação E só é true quando tanto o A quanto o B forem true
Se um dos dois for false a expressão toda é false

Você não está notando a diferença pois está fazendo uma operação aritmética com operandos boolean

A && B é uma operação lógica, quando o A for false ele nem vai avaliar o B pois, conforme a tabela verdade, basta ter um false para o resultado ser false

A & B é uma operação aritmética.

Um boolean de valor false nada mais é do que um byte de valor 0, ou seja, os seguinte 8 bits: 00000000

Um boolean de valor true nada mais é do que um byte de valor 1, ou seja, os seguinte 8 bits: 00000001

Então o processador vai realizar a operação E com os bits do A e do B, isto é: 00000000 & 00000001 = 00000000

Os bits 00000000 equivalem à um byte de valor 0, que equivale à um boolean de valor false

Resumindo:

Quando quiser fazer testes LÓGICOS, utilize os operadores LÓGICOS && e ||

Quando quiser fazer operações aritméticas com os bits de variáveis inteiras, utilize os operadores ARITMÉTICOS & e |.

Estou dando uma olhada aqui. Lembra um pouco a matéria de conjuntos do colégio.

Vou fechar a tópico por aqui.
Muito obrigado a todos, as respostas de vocês me foram muito esclarecedoras.
Valeu