Você está aqui: Cards de Cards de Hidrologia
Card 1 de 75
O regime de escoamento laminar

O regime laminar na hidrologia refere-se ao tipo de fluxo de água que ocorre em um corpo d'água, como um rio ou um lago, onde o movimento da água é suave e ordenado. Nesse regime, as camadas de água deslizam umas sobre as outras de maneira paralela, sem causar turbulência.

Esse tipo de fluxo é caracterizado por um baixo número de Reynolds, o que significa que a viscosidade da água é predominante em relação às forças inerciais. O regime laminar é comum em águas calmas ou em seções de rios com baixa inclinação e velocidade de fluxo.

O entendimento do regime laminar é importante para a modelagem de transporte de sedimentos, a qualidade da água e a gestão de recursos hídricos, pois influencia a dinâmica do ecossistema aquático e a erosão das margens.

Filtrar Cards
Use esta opção para filtrar os cards pelos tópicos que mais lhe interessam.
Termos:
Aviso Importante: Nos esforçamos muito para que o conteúdo dos cards e dos testes e conhecimento seja o mais correto possível. No entanto, entendemos que erros podem ocorrer. Caso isso aconteça, pedimos desculpas e estamos à disposição para as devidas correções. Além disso, o conteúdo aqui apresentado é fruto de conhecimento nosso e de pesquisas na internet e livros. Caso você encontre algum conteúdo que não deveria estar aqui, por favor, nos comunique pelos e-mails exibidos nas opções de contato.
Link para compartilhar na Internet ou com seus amigos:

Java ::: Classes e Componentes ::: JTree

Java Swing - Como criar sua primeira JTree usando um vetor de nomes de linguagens de programação

Quantidade de visualizações: 13463 vezes
Este exemplo mostra como criar uma JTree bem simples, e que servirá de base para a criação de aplicações Java Swing mais elaboradas. Os itens da JTree são fornecidos como um vetor de objetos, de forma que cada sub-vetor constitui uma seção da árvore. Os elementos (nós) são inseridos em suas devidas posições usando uma função recursiva.

Veja o resultado na figura abaixo:



E agora o código Java completo para o exemplo:

package arquivodecodigos;

import javax.swing.*;
import java.awt.*;
import javax.swing.tree.*;
 
public class Estudos extends JFrame{
  public Estudos(){
    super("Exemplo de uma JTree simples");
     
    Object[] linguagens = {
      "Linguagens",
      new Object[]{
        "Compiladas",
        "C++",
        "Delphi"
      }, 
      new Object[]{
        "Interpretadas",
        "JavaScript",
        "Python",
        "Ruby"
      }
    };
 
    DefaultMutableTreeNode raiz = montar(linguagens);
    JTree arvore = new JTree(raiz);  
 
    Container c = getContentPane();
    c.setLayout(new FlowLayout());
             
    JScrollPane scrollPane = new JScrollPane(arvore);
    c.add(scrollPane);
         
    setSize(400, 300);
    setVisible(true);
  }
     
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
 
  private DefaultMutableTreeNode montar(Object[] hier){
    DefaultMutableTreeNode no = new DefaultMutableTreeNode(hier[0]), filho;
     
    for(int i = 1; i < hier.length; i++){
      Object n_no = hier[i];
      if(n_no instanceof Object[]){ // nó possui filhos
        filho = montar((Object[])n_no);
      }
      else{
        filho = new DefaultMutableTreeNode(n_no); // folha
      }
      
      no.add(filho);
    }
 
    return(no);
  }
}



Java ::: Coleções (Collections) ::: ArrayList

Como excluir de uma ArrayList todos os elementos contidos em outra ArrayList ou coleção do Java usando o método removeAll()

Quantidade de visualizações: 10356 vezes
Em algumas situações pode ser útil sabermos como remover de uma ArrayList todos os elementos contidos em outra ArrayList ou coleção. Para isso podemos usar o método removeAll(), que a classe ArrayList herda da interface java.util.List.

Veja sua assinatura:

boolean removeAll(Collection<?> c)


E agora veja um exemplo de seu uso:

import java.util.ArrayList;

public class Estudos{
  public static void main(String[] args){
    // cria uma ArrayList que conterá strings
    ArrayList<String> nomes = new ArrayList<String>();

    // cria uma segunda ArrayList que conterá mais strings
    ArrayList<String> nomes2 = new ArrayList<String>();
    
    // adiciona itens na primeira lista
    nomes.add("Carlos");
    nomes.add("Maria");
    nomes.add("Fernanda");
    nomes.add("Osmar");
    nomes.add("Zacarias");    

    // adiciona itens na segunda lista
    nomes2.add("Maria");
    nomes2.add("Zacarias");    
	
    // vamos remover da primeira lista todos os elementos
    // contidos na segunda lista
    nomes.removeAll(nomes2);

    // vamos exibir o resultado
    for(int i = 0; i < nomes.size(); i++){
      System.out.println(nomes.get(i));
    } 

    System.exit(0);
  }
}



C ::: Dicas & Truques ::: Struct (Estruturas, Registros)

Linguagem C para iniciantes - Como usar estruturas (struct) em C

Quantidade de visualizações: 68718 vezes
Vetores e matrizes (arrays) são muito importantes quando precisamos agrupar várias variáveis de um mesmo tipo de dados. Porém, há casos em que precisamos agrupar variáveis de diferentes tipos. Para estes casos a linguagem C nos fornece as estruturas (struct). Veja como declará-las:

// uma estrutura Pessoa
struct Pessoa
{
  char *nome;
  int idade;
};

Veja que esta estrutura possui dois tipos de dados diferentes: um ponteiro para uma cadeia de caracteres e uma variável do tipo int.

Para declarar variáveis do tipo Pessoa você tem duas opções. A primeira consiste em declarar as variáveis juntamente com a declaração da estrutura. Veja:

// uma estrutura Pessoa
struct Pessoa
{
  char *nome;
  int idade;
}pessoa, cliente, chefe;

A outra forma consiste em declarar a variável no local no qual ela será usada. Esta forma é mais prática. Veja um exemplo completo de como isso é feito:

#include <stdio.h>
#include <stdlib.h>

// uma estrutura Pessoa
struct Pessoa
{
  char *nome;
  int idade;
};

int main(int argc, char *argv[])
{
  // declara uma variável do tipo struct
  struct Pessoa cliente;
  cliente.nome = "Osmar J. Silva";
  cliente.idade = 36;

  // obtém os dados
  printf("O nome do cliente e: %s\n", cliente.nome);
  printf("A idade do cliente e: %d\n", cliente.idade);

  printf("\n\n");
  system("PAUSE");
  return 0;
}



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Hidrologia e Hidráulica

Exercícios Resolvidos de Java - Como aplicar a Fórmula da Vazão pelo Método Racional em Java - De acordo com o método racional, a vazão máxima a ser considerada

Quantidade de visualizações: 443 vezes
Pergunta/Tarefa:

Neste exercício de Java nós veremos como aplicar a Fórmula da Vazão pelo Método Racional para resolver uma questão de Hidrologia que caiu no concurso para Analista na Área de Engenharia Sanitária do MPE-MS em 2013.

1) De acordo com o método racional, a vazão máxima a ser considerada no projeto de um bueiro para uma chuva de intensidade igual a 2 mm/h, com duração igual ou superior ao tempo de concentração da bacia de contribuição que possui área igual a 18 km2 e coeficiente de escoamento superficial igual a 0,7 será, em m3/s, igual a

A) 5,4.

B) 7,0.

C) 11,5.

D) 14,0.

E) 25,2.

Sua saída deve ser parecida com:

Intensidade da chuva em mm/h: 2
Área da bacia em quilômetros quadrados: 18
Coeficiente de escoamento: 0.7
A vazão máxima é: 7.0
Resposta/Solução:

O primeiro passo para resolver esta questão é relembrando a fórmula da Vazão pelo Método Racional. Apresentado pela primeira vez em 1851 por Mulvaney e usado por Emil Kuichling em 1889, o Método Racional é um método indireto e estabelece uma relação entre a chuva e o escoamento superficial (deflúvio).

Usamos esta fórmula para calcular a vazão de pico de uma determinada bacia, considerando uma seção de estudo.

Eis a fórmula:

\[Q = \frac{C \cdot I \cdot A}{360} \]

Onde:

Q = vazão de pico (m3/s);

C = coeficiente de escoamento superficial que varia de 0 a 1.

I = intensidade média da chuva (mm/h);

A = área da bacia (ha), onde 1 ha = 10.000m2

Na questão do concurso nós já temos a intensidade da chuva em milímetros por hora, mas a área da bacia está em quilômetros quadrados, o que exigirá uma conversão para hectares. No código Java eu mostro essa parte comentada.

Então, hora de vermos a resolução comentada deste exercício usando Java:

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 ler a precipitação ou intensidade da chuva em mm/h
    System.out.print("Intensidade da chuva em mm/h: ");
    double intensidade = Double.parseDouble(entrada.nextLine());
    
    // vamos ler a área da bacia em quilômetros quadrados
    System.out.print("Área da bacia em quilômetros quadrados: ");
    double area_bacia = Double.parseDouble(entrada.nextLine());
    
    // vamos ler o coeficiente de escoamento
    System.out.print("Coeficiente de escoamento: ");
    double coeficiente = Double.parseDouble(entrada.nextLine());
    
    // agora vamos transformar quilômetros quadrados em
    // hectares
    area_bacia = area_bacia * 100;
    
    // e vamos calcular a vazão de pico em metros cúbicos
    double vazao = ((coeficiente * intensidade * area_bacia) / 360.0);
    
    // e mostramos o resultado
    System.out.println("A vazão máxima é: " + vazao);
  }
}



C++ ::: Dicas & Truques ::: Ponteiros, Referências e Memória

Como alocar memória dinâmica usando o operador new do C++

Quantidade de visualizações: 12463 vezes
Em algumas situações precisamos alocar memória dinamicamente. Em C++ isso é feito com o auxílio do operador new. Este operador permite alocar uma determinada quantidade de bytes, alinhados de forma a representar o objeto para o qual queremos reservar memória.

Veja um exemplo de código no qual alocamos memória dinâmica para uma variável do tipo int:

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  // aloca memória para um objeto do tipo int
  int *ponteiro = new int;

  // vamos definir o valor para o objeto recém-alocado
  *ponteiro = 20;

  // vamos exibir seu valor
  cout << *ponteiro << endl;

  // vamos liberar a memória
  delete ponteiro;

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Note que aqui a memória foi alocada e guardada em um ponteiro. Veja também o uso do operador delete para liberar a memória alocada. Isso evita os vazamentos de memória tão frequentes em aplicações que lidam com a memória dinâmica.

É claro que este não é o exemplo mais prático. Qual a vantagem de se alocar memória para um int? Declarar uma variável teria sido mais eficiente.

A alocação de memória dinâmica é mais útil quando estamos lidando com objetos mais complexos que os tipos básicos. Alguns exemplos envolvem a criação de objetos de classes, matrizes, estruturas de dados, etc.

Veja um exemplo no qual temos uma declaração de uma classe chamada Cliente e em seguida alocamos memória para uma instância desta classe:

#include <iostream>
#include <string>

using namespace std;

// declaração da classe Cliente
class Cliente{
  public:
    Cliente();
    string obterNome();
    void definirNome(string);
  private:
    string nome;
};

// implementação dos métodos da classe
Cliente::Cliente(){} // construtor vazio

// obtém o nome do cliente
string Cliente::obterNome(){
  return this->nome;
}

// define o nome do cliente
void Cliente::definirNome(string nome){
  this->nome = nome;
}

int main(int argc, char *argv[]){
  // aloca memória para um objeto da classe Cliente
  Cliente *c = new Cliente();

  // vamos definir o nome do cliente
  c->definirNome("Osmar J. Silva");

  // vamos exibir o nome do cliente
  cout << c->obterNome() << endl;

  // vamos liberar a memória usada
  delete c;

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Ao executar este código C++ nós teremos o seguinte resultado:

Nome do cliente: Osmar J. Silva


Desafios, Exercícios e Algoritmos Resolvidos de C++

Veja mais Dicas e truques de C++

Dicas e truques de outras linguagens

E-Books em PDF

E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby


E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser. Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book Apenas R$ 32,90

Planilha Web - Planilhas e Calculadoras online para estudantes e profissionais de Engenharia Civil, Engenharia Elétrica e Engenharia Mecânica.


© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 85 usuários muito felizes estudando em nosso site.