----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;
 
import java.util.Scanner;
 
public class Estudos {
  public static void main(String[] args) {
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
   
    // vamos pedir para o usuário informar a altura da lâmina
    // de água em milímetros
    System.out.print("Altura da lâmina de água em milímetros: ");
    double altura_lamina = Double.parseDouble(entrada.nextLine());

    // o primeiro passo é converter os milímetros da lâmina de água
    // para metros
    altura_lamina = altura_lamina / 1000.00;

    // agora que já temos a altura da lâmina em metros, vamos multiplicar
    // pela base (1 metro quadrado) para obtermos o volume da chuva por
    // metro quadrado
    double volume_chuva = (altura_lamina * 1.00) * 1000.00;

    // vamos mostrar o resultado
    System.out.println("O volume da chuva é: " + volume_chuva +
      " litros para cada metro quadrado");
  }
}

Inserindo 5 valores na lista

Informe o 1.o valor: 8
Informe o 2.o valor: 2
Informe o 3.o valor: 4
Informe o 4.o valor: 7
Informe o 5.o valor: 3

Valores na lista: 8 -> 2 -> 4 -> 7 -> 3 -> null

Inserindo um elemento no índice k

Informe o índice desejado: 2
Informe o valor do nó: 9

Valores na lista: 8 -> 2 -> 9 -> 4 -> 7 -> 3 -> null

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;
  
import java.util.Scanner;

// classe interna usada para representar um
// nó na lista ligada
class No {
  int valor; // valor do nó
  No proximo; // aponta para o novo nó
 
  // construtor cheio da classe No
  public No(int valor, No proximo) {
    this.valor = valor;
    this.proximo = proximo;
  }
  
  // construtor vazio da classe No
  public No() {
    this.valor = 0;
    this.proximo = null;
  }
}

public class Estudos { 
  public static void main(String args[]){
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos criar uma referência para o início da lista
    No inicio = null;
    
    // vamos inserir 5 valores inteiros na lista ligada
    int valor;
    System.out.println("Inserindo 5 valores na lista\n");
    for (int i = 0; i < 5; i++) {
      System.out.print("Informe o " + (i + 1) + ".o valor: ");
      valor = Integer.parseInt(entrada.nextLine());
      // vamos inserir este valor no final da lista
      inicio = inserirFinal(inicio, valor);
    }
    
    // vamos exibir os valores na lista ligada
    System.out.print("\nValores na lista: ");
    exibirLista(inicio);
    
    // vamos inserir um novo elemento no índice informado
    System.out.println("\nInserindo um elemento no índice k\n");
    System.out.print("Informe o índice desejado: ");
    int indice = Integer.parseInt(entrada.nextLine());
    
    // o índice é válido?
    if ((indice < 0) || (indice > tamanhoLista(inicio) - 1)) {
      System.out.println("O índice é inválido.");
    }
    else {
      // vamos inserir o novo nó no índice indicado
      System.out.print("Informe o valor do nó: ");
      valor = Integer.parseInt(entrada.nextLine());
      inicio = inserirIndice(inicio, indice, valor);
      
      // vamos exibir os valores na lista ligada
      System.out.print("\nValores na lista: ");
      exibirLista(inicio);
    }
  }
  
  // função que permite adicionar um nó em uma determinada
  // posição da lista ligada
  public static No inserirIndice(No inicio, int indice, int valor) {
    // vamos apontar para o nó inicial
    No atual = inicio;
    // criamos um novo nó
    No novo = criarNo(valor);
    
    // a lista ligada ainda está vazia?
    if (atual == null){
      // inicio recebe o novo nó
      inicio = novo;
    }
    else if (indice == 0) {
      // o índice é igual a 0? vamos inserir
      // o nó no início da lista ligada
      novo.proximo = inicio;
      inicio = novo;
    }
    else {
      // vamos procurar o local adequado para inserção
      // primeiro criamos um nó temporário
      No temp = new No();
      // apontamos o nó temporário para o início da lista
      temp = inicio;
      // e percorremos os nós até encontrar a posição
      // de inserção
      for(int i = 1; i < indice; i++) {
        if (temp != null) {
          // passa para o próximo nó
          temp = temp.proximo;
        }
      }
   
      // concluimos a inserção
      novo.proximo = temp.proximo;
      temp.proximo = novo;
    }
    
    // e retornamos o início da lista
    return inicio;
  }

  // função que permite adicionar um nó no final da
  // lista ligada
  public static No inserirFinal(No inicio, int valor) {
    // vamos apontar para o nó inicial
    No atual = inicio;
    // criamos um novo nó
    No novo = criarNo(valor);
  
    // a lista ligada ainda está vazia?
    if (atual == null){
      // inicio recebe o novo nó
      inicio = novo;
    }    
    else { // temos um ou mais nós na lista ligada
      // vamos localizar o último nó
      while (atual.proximo != null) {
        atual = atual.proximo;
      }
       
      // encontramos o último nó. Agora vamos inserir
      // o novo nó depois dele
      atual.proximo = novo;
    }
     
    // e retornamos o início da lista
    return inicio;
  }
  
  // função usada para construir e retornar um novo nó
  public static No criarNo(int valor) {
    // cria o novo nó
    No no = new No(valor, null);
    // retorna o nó criado
    return no;
  }
  
  // função usada para percorrer a lista ligada e
  // exibir os valores contidos em seus nós
  public static void exibirLista(No inicio) {
    // vamos apontar para o início da lista
    No temp = inicio;
    
    // a lista está vazia?
    if (temp == null) {
      System.out.println("A lista está vazia.");
    }
    else {
      // esse laço se repete enquanto tempo for
      // diferente de null
      while (temp != null) {
        // vamos mostrar o valor desse nó
        System.out.print(temp.valor + " -> ");
        // avança para o próximo nó
        temp = temp.proximo;
      }
    
      // mostra o final da lista
      System.out.println("null");
    }
  }
  
  // função que retorna a quantidade de nós na lista ligada
  public static int tamanhoLista(No inicio) {
    int tamanho = 0;
    
    // vamos apontar para o início da lista
    No temp = inicio;
    
    // a lista está vazia?
    if (temp == null) {
      return 0;
    }
    else {
      // esse laço se repete enquanto tempo for
      // diferente de null
      while (temp != null) {
        // vamos incrementar o tamanho
        tamanho++;
        // avança para o próximo nó
        temp = temp.proximo;
      }
    }
    
    return tamanho;
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;
 
public class Estudos{
  public static void main(String args[]){
    // declarar, construir e inicializar as matrizes
    int matrizA[][] = {{3, 4, -1}, {8, 2, 1}, {7, 5, -3}};
    int matrizB[][] = {{-2, 6, 4}, {1, 8, 9}, {-4, 10, 3}};
    
    // esta é a matriz soma
    int matrizSoma[][] = new int[3][3];  
    
    // e agora vamos prosseguir com a soma
    for(int i = 0; i < matrizA.length; i++){
      for(int j = 0; j < matrizA[0].length; j++){
        matrizSoma[i][j] = matrizA[i][j] + matrizB[i][j];     
      } 
    }
    
    // vamos exibir os valores da primeira matriz
    System.out.println("Elementos da matriz A:");
    for(int i = 0; i < matrizA.length; i++){
      for(int j = 0; j < matrizA[0].length; j++){
        System.out.printf("%5d  ", matrizA[i][j]);
      }
      System.out.println();
    }
    
    // vamos exibir os valores da primeira matriz
    System.out.println("\nElementos da matriz B:");
    for(int i = 0; i < matrizB.length; i++){
      for(int j = 0; j < matrizB[0].length; j++){
        System.out.printf("%5d  ", matrizB[i][j]);
      }
      System.out.println();
    }
    
    // vamos exibir os valores da matriz soma
    System.out.println("\nElementos da matriz soma:");
    for(int i = 0; i < matrizSoma.length; i++){
      for(int j = 0; j < matrizSoma[0].length; j++){
        System.out.printf("%5d  ", matrizSoma[i][j]);
      }
      System.out.println();
    }
  }
}

Elementos da matriz A:
    3      4     -1  
    8      2      1  
    7      5     -3  

Elementos da matriz B:
   -2      6      4  
    1      8      9  
   -4     10      3  

Elementos da matriz soma:
    1     10      3  
    9     10     10  
    3     15      0

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;

import java.util.Scanner;

public class Estudos{
  public static void main(String[] args){
    // vamos usar a classe Scanner para leitura
    Scanner entrada = new Scanner(System.in);

    // declara e constrói um vetor de 10 inteiros
    int valores[] = new int[10];
    
    // vamos ler os valores dos elementos do vetor
    for(int i = 0; i < valores.length; i++){
      System.out.print("Informe o valor: ");
      valores[i] = Integer.parseInt(entrada.nextLine());
    }
    
    // já temos o vetor. Agora vamos verificar se temos
    // uma progressão geométrica
    boolean progressao = true;
    // vamos obter a razão
    int razao = valores[1] / (valores[0]);
    
    // vamos varrer os elementos do vetor e verificar se todos
    // possuem a mesma razão
    for(int i = 1; i < valores.length; i++){
      if((valores[i] / (valores[i - 1])) != razao){
        progressao = false;
        break;
      }
    }
    
    if(progressao){
      System.out.println("Formam uma progressão geométrica.");
      System.out.println("A razão é: " + razao);
      System.out.println("O primeiro termo é: " + valores[0]);
    }
    else{
      System.out.println("Não formam uma progressão geométrica.");
    }
  }
}